{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b44dfb65",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "#  10\\.  逻辑回归实现与应用  # \n",
    "\n",
    "##  10.1.  介绍  # \n",
    "\n",
    "逻辑回归（Logistic Regression），又叫逻辑斯蒂回归，是机器学习中一种十分基础的分类方法，由于算法简单而高效，在实际场景中得到了广泛的应用。本次实验中，我们将探索逻辑回归的原理及算法实现，并使用 scikit-learn 构建逻辑回归分类预测模型。 \n",
    "\n",
    "##  10.2.  知识点  # \n",
    "\n",
    "  * 线性可分和不可分 \n",
    "\n",
    "  * Sigmoid 分布函数 \n",
    "\n",
    "  * 逻辑回归模型 \n",
    "\n",
    "  * 对数损失函数 \n",
    "\n",
    "  * 梯度下降法 \n",
    "\n",
    "逻辑回归，当你听到这个名字之后，我相信你首先注意到的是「回归」。前面我们已经学习了线性回归，那么逻辑回归有何其有什么区别与联系呢。 \n",
    "\n",
    "不过，本次实验刚开始就需要强调：逻辑回归是一种分类方法，而并不是回归方法。你需要牢牢记住，不要混淆。那么，逻辑回归为什么要取一个带「回归」字样的名字呢？它真的和前面所说的回归方法一点关系都没有吗？ \n",
    "\n",
    "关于这个问题，学习完本次实验的全部内容，相信你就会得到答案。 \n",
    "\n",
    "##  10.3.  线性可分和不可分  # \n",
    "\n",
    "首先，我们需要先接触一个概念，那就是线性可分。如下图所示，二维平面内，如果只使用一条直接就可以将样本分开，则称为线性可分，否则为线性不可分。 \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710457777.png)\n",
    "\n",
    "当然，如果在三维空间内，可以通过一个平面去将样本分开，也称为线性可分。由于本次实验不会涉及，这里就先不深入了。 \n",
    "\n",
    "##  10.4.  使用线性回归分类  # \n",
    "\n",
    "前面的实验中，我们重点学习了线性回归。简单概括起来，线性回归是通过拟合一条直线去预测更多的连续值。其实，除了回归问题，线性回归也可以用来处理特殊情况下的分类问题。例如： \n",
    "\n",
    "如果我们有如下的数据集，这个数据集仅包含有 1 个特征和 1 个目标值。例如，我们对某一门课程的学员成绩进行统计，通过学习时长决定这门课程是否 PASS。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c9cea5f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = [\n",
    "    [1],\n",
    "    [1],\n",
    "    [2],\n",
    "    [2],\n",
    "    [3],\n",
    "    [3],\n",
    "    [3],\n",
    "    [4],\n",
    "    [4],\n",
    "    [5],\n",
    "    [6],\n",
    "    [6],\n",
    "    [7],\n",
    "    [7],\n",
    "    [8],\n",
    "    [8],\n",
    "    [8],\n",
    "    [9],\n",
    "    [9],\n",
    "    [10],\n",
    "]\n",
    "passed = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "439f7ee7",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "上面的数据集中， ` passed  ` 只有  $0$  和  $1$  ，也就是数值型数据。不过，这里我们将  $0$  和  $1$  分别表示为通过和不通过，那么就转换成了一个分类问题。并且，这是一个典型的二分类问题。二分类表示只有两种类别，也可以称之为：  $0-1$  分类问题。 \n",
    "\n",
    "对于这样一个二分类问题，怎样用线性回归去解决呢？ \n",
    "\n",
    "在这里，我们可以定义：通过线性拟合函数  $f(x)$  计算的结果  $f(x)>0.5$  （靠近 1）代表 ` PASS  ` ，而  $f(x)<=0.5$  （靠近 0）代表不通过。 \n",
    "\n",
    "$$\\begin{split} \\begin{array}{l}{f(x)>0.5=>y=1} \\\\\\ {f(x) \\leq 0.5=>y=0}\\end{array} \\end{split}$$ \n",
    "\n",
    "这样，就可以巧妙地使用线性回归去解决二分类问题了。 \n",
    "\n",
    "下面，我们就开始实战内容。首先，绘制数据集对应到二维平面中的散点图。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b87fb95f",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'passed')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.scatter(scores, passed, color=\"r\")\n",
    "plt.xlabel(\"scores\")\n",
    "plt.ylabel(\"passed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02df0e5f",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "然后，我们使用 scikit-learn 完成线性回归拟合的过程，相信通过学习前面的内容，你应该对线性回归拟合过程十分熟悉了。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5f523147",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.1446863]), np.float64(-0.36683738796414833))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "model = LinearRegression()\n",
    "model.fit(scores, passed)\n",
    "model.coef_, model.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f22b692",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "接下来，将拟合直线绘制到散点图中。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "60ca73c3",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'passed')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.linspace(-2, 12, 100)\n",
    "\n",
    "plt.plot(x, model.coef_[0] * x + model.intercept_)\n",
    "plt.scatter(scores, passed, color=\"r\")\n",
    "plt.xlabel(\"scores\")\n",
    "plt.ylabel(\"passed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9b71e8",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "\n",
    "如果按照上面的定义，即通过线性拟合函数  $f(x)$  计算的结果  $f(x)>0.5$  代表 ` PASS  ` ，而  $f(x)<=0.5$  代表不通过。 \n",
    "\n",
    "那么，如下图所示，凡是 ` scores  ` 大于橙色竖线对应  $x$  坐标值的部分均会被判断为 ` PASS  ` ，也就是被棕色选框圈出的 ` 2  ` 个点就被错误分类。 \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710458119.png)\n",
    "\n",
    "##  10.5.  Sigmoid 分布函数  # \n",
    "\n",
    "上面的内容中，虽然我们可以使用线性回归解决二分类问题，但它的结果并不理想。尤其是在完成  $0-1$  分类问题中，线性回归在计算过程中还可能产生负值或大于  $1$  的数。所以，在今天的实验内容，我们可以通过一种叫做逻辑回归的方式来更好地完成  $0-1$  分类问题。 \n",
    "\n",
    "这里, 我们需要先接触到一个叫做 Sigmoid 的函数，这个函数的定义如下： \n",
    "\n",
    "$$ f(z)=\\frac{1}{1+e^{-z}} \\tag{2} $$ \n",
    "\n",
    "你可能感觉有一些懵，为什么突然要介绍这样一个函数呢？下面，我们将这个函数的曲线绘制出来看一看，或许你就明白了。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "69537836",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    sigmoid = 1 / (1 + np.exp(-z))\n",
    "    return sigmoid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93c4a20c",
   "metadata": {},
   "source": [
    "这段代码定义了一个 **Sigmoid 函数**，这是机器学习和深度学习中常用的激活函数，尤其是在逻辑回归和神经网络中。以下是逐行解释：\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd43f2a6",
   "metadata": {},
   "source": [
    "def sigmoid(z):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15848060",
   "metadata": {},
   "source": [
    "- 定义一个名为 `sigmoid` 的函数，接收一个参数 `z`。\n",
    "- `z` 可以是一个标量、向量或矩阵。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b4b0499",
   "metadata": {},
   "source": [
    "    sigmoid = 1 / (1 + np.exp(-z))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fccf8d5",
   "metadata": {},
   "source": [
    "- 计算 Sigmoid 函数的值，公式为：\n",
    "\n",
    "\\[\n",
    "\\sigma(z) = \\frac{1}{1 + e^{-z}}\n",
    "\\]\n",
    "\n",
    "- `np.exp(-z)` 计算 \\( e^{-z} \\)，其中 \\( e \\) 是自然对数的底。\n",
    "- `1 / (1 + np.exp(-z))` 是 Sigmoid 函数的完整公式，输出值范围在 (0, 1) 之间。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da0c5dd4",
   "metadata": {},
   "source": [
    "- 返回计算得到的 Sigmoid 值。\n",
    "\n",
    "### Sigmoid 函数的作用\n",
    "1. **非线性映射**：将输入值 \\( z \\) 映射到 (0, 1) 的范围。\n",
    "2. **概率输出**：在逻辑回归中，Sigmoid 函数常用于将模型的线性输出转换为概率值。\n",
    "3. **平滑性**：Sigmoid 函数是连续且可微的，适合用于梯度下降优化。\n",
    "\n",
    "### 示例\n",
    "假设输入 \\( z = 0 \\)：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dee2854b",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 0\n",
    "sigmoid_value = sigmoid(z)  # 输出为 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f18df485",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Sigmoid 函数的输出在 \\( z \\to -\\infty \\) 时接近 0，\\( z \\to +\\infty \\) 时接近 1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "df6f9dc7",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "z = np.linspace(-12, 12, 100)  # 生成等间距 x 值方便绘图\n",
    "plt.plot(z, sigmoid(z))\n",
    "plt.xlabel(\"z\")\n",
    "plt.ylabel(\"y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30b4b6d2",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "上图就是 Sigmoid 函数的图像，你会惊讶地发现，这个图像呈现出完美的 S 型（Sigmoid 的含义）。它的取值仅介于  $0$  和  $1$  之间，且关于  $z=0$  轴中心对称。同时当  $z$  越大时，  $y$  越接近于  $1$  ，而  $z$  越小时，  $y$  越接近于  $0$  。如果我们以  $0.5$  为分界点，将  $>0.5$  或  $<0.5$  的值分为两类，这不就是解决  $0-1$  二分类问题的完美选择嘛。 \n",
    "\n",
    "##  10.6.  逻辑回归模型  # \n",
    "\n",
    "前面的例子中，实验通过线性回归去完成分类问题。发现拟合后的线性函数的 y 值介于  $\\left ( - \\infty,+ \\infty \\right )$  之间。其中提到了 Sigmoid 函数，它的  $y$  值介于  $\\left ( 0,1 \\right )$  之间。 \n",
    "\n",
    "这里又要引入一条数学定义。那就是，如果一组连续随机变量符合 Sigmoid 函数样本分布，就称作为逻辑分布。逻辑分布是概率论中的定理，是一种连续型的概率分布。 \n",
    "\n",
    "那么，这里就考虑将二者结合起来，也就是把线性函数拟合的结果使用 Sigmoid 函数压缩到  $\\left ( 0,1 \\right )$  之间。如果线性函数的  $y$  值越大，也就代表概率越接近于 1，反之接近于 0。 \n",
    "\n",
    "所以，在逻辑回归中，定义： \n",
    "\n",
    "$$ z_{i} = {w_0}{x_0} + {w_1}{x_1} + \\cdots + {w_i}{x_i} = {w^T}x \\tag{3a} $$ \n",
    "\n",
    "$$ f(z_{i})=\\frac{1}{1+e^{-z_{i}}} \\tag{3b} $$ \n",
    "\n",
    "公式  $(3)$  中，我们对每一个特征  $x$  乘上系数  $w$  ，然后通过 Sigmoid 函数计算  $f(z)$  值得到概率。其中，  $z$  可以被看作是分类边界。故： \n",
    "\n",
    "$$ h_{w}(x) = f({w^T}x)=\\frac{1}{1+e^{-w^Tx}} \\tag{4} $$ \n",
    "\n",
    "由于目标值  $y$  只有 0 和 1 两个值，那么如果记  $y=1$  的概率为  $h_{w}(x)$  ，则此时  $y=0$  的概率为  $1-h_{w}(x)$  。那么，我们可以记作逻辑回归模型条件概率分布： \n",
    "\n",
    "$$\\begin{split} P(Y=y |\n",
    "                    x)=\\left\\{\\begin{array}{rlrl}{h_{w}(x)} & {, y=1} \\\\\n",
    "                    {1-h_{w}(x)} & {, y=0}\\end{array}\\right. \\end{split}$$ \n",
    "\n",
    "上方公式  $(5)$  不方便计算，其可等价写为似然函数： \n",
    "\n",
    "$$ P(y|x ; w)=\\left(h_{w}(x)\\right)^{y}\\left(1-h_{w}(x)\\right)^{1-y} \\tag{6} $$ \n",
    "\n",
    "你可以验证公式  $(6)$  的含义为，当  $y=1$  是，概率为  $h_{w}(x)$  ，  $y=0$  的概率为  $1-h_{w}(x)$  。 \n",
    "\n",
    "上面我们只是拿一个样本举例，对于  $i$  个样本的总概率而言实际上可以看作单样本概率的乘积，记为  $L(w)$  ： \n",
    "\n",
    "$$ L(w) =\\prod_{i=1}^{m}\\left(h_{w}\\left(x^{(i)}\\right)\\right)^{y^{(i)}}\\left(1-h_{w}\\left(x^{(i)}\\right)\\right)^{1-y^{(i)}} \\tag{7} $$ \n",
    "\n",
    "由于连乘表示起来非常复杂，我们应用数学技巧，即两边取对数将连乘转换为连加的形式，即： \n",
    "\n",
    "$$ \\log L(w)=\\sum_{i=1}^{m} \\left [ y^{(i)} \\log h_{w}\\left(x^{(i)}\\right)+\\left(1-y^{(i)}\\right) \\log \\left(1-h_{w}\\left(x^{(i)}\\right)\\right)\\right ] \\tag{8} $$ \n",
    "\n",
    "##  10.7.  对数损失函数  # \n",
    "\n",
    "实际上，公式  $(8)$  被称为对数似然函数，该函数衡量了事件发生的总概率。根据最大似然估计原理，只需要通过对  $L(w)$  求最大值，即得到  $w$  的估计值。而在机器学习问题中，我们需要一个损失函数，并通过求其最小值来进行参数优化。所以，对数似然函数取负数就可以被作为逻辑回归的对数损失函数： \n",
    "\n",
    "$$ J(w) =- \\frac{1}{m} \\sum_{i=1}^{m} \\left [ y^{(i)} \\log h_{w}\\left(x^{(i)}\\right)+\\left(1-y^{(i)}\\right) \\log \\left(1-h_{w}\\left(x^{(i)}\\right)\\right)\\right ] \\tag{9} $$ \n",
    "\n",
    "为了衡量整个数据集上的平均损失，所以公式  $(9)$  在全部样本上求取了平均值，构成逻辑回归最终的对数损失函数。此时，你可能会想到逻辑回归为什么不用线性回归中的平方损失函数呢？ \n",
    "\n",
    "这其实是有数学依据的。我们设置损失函数的目的是接下来通过最优化方法求得损失函数的最小值，损失最小即代表模型最优。在最优化求解中，只有 [ 凸函数 ](https://zh.wikipedia.org/zh-hans/%E5%87%B8%E5%87%BD%E6%95%B0) 往往才能求得全局最小值，非凸函数往往得到的是局部最优。然而，平方损失函数用于逻辑回归求解时得到的是非凸函数，即大多数情况下无法求得全局最优。这里使用了对数损失函数就避免了这个问题。 \n",
    "\n",
    "![](https://cdn.aibydoing.com/aibydoing/images/uid214893-20190710-1562739820224.svg)\n",
    "\n",
    "[ 来源 ](https://en.wikipedia.org/wiki/Maxima_and_minima)\n",
    "\n",
    "如上所示的非凸函数中，存在全局最小值 Global Minimum 和局部最小值 Local Minimum。 \n",
    "\n",
    "当然，上面这句话涉及到很多数学知识。尤其是像最优化理论，是研究生课程阶段才会涉及到的内容，理解起来会有一些困难。如果你无法理解，就记住逻辑回归中，我们使用到的是对数损失函数即可。 \n",
    "\n",
    "下面，我们用代码实现公式  $(9)$  ： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e3203989",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(h, y):\n",
    "    loss = (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e67671c",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  10.8.  梯度下降法  # \n",
    "\n",
    "上面，我们已经成功定义并实现了对数损失函数。所以，现在离求解最优参数只有一步之遥了，那就是求得损失函数的极小值。 \n",
    "\n",
    "为了求解公式  $(9)$  的极小值，这里引入一种叫「梯度下降」的求解方法。梯度下降法是一种十分常用且经典的最优化算法，通过这种方法我们就能快速找到函数的最小值。下面将讲解梯度下降法的原理，希望你能认真理解，后面的许多内容都会运用到梯度下降方法。 \n",
    "\n",
    "要理解梯度下降，首先得清楚什么是「梯度」？梯度是一个向量，它表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模）。简而言之，对于一元函数而言，梯度就是指在某一点的导数。而对于多元函数而言，梯度就是指在某一点的偏导数组成的向量。 \n",
    "\n",
    "既然，函数在沿梯度方向变化最快，所以「梯度下降法」的核心就是，我们沿着梯度下降方向去寻找损失函数的极小值（梯度的反方向）。过程如下图所示。 \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710458293.jpg)\n",
    "\n",
    "所以，我们针对公式  $(9)$  求偏导数，得到梯度。但现在式  $(9)$  比较复杂，所以先对式  $(9)$  进行化简，先来看  $\\log (h_{w}(x^{(i)}))$  ，结合式  $(4)$  得： \n",
    "\n",
    "$$\\begin{split} \\begin{align} \\log (h_{w}(x^{(i)}) & = \\log(f({w^T}x^{(i)})) \\\\\\ & = \\log(\\frac{1}{1+e^{-w^Tx^{(i)}}})\\\\\\ & = -\\log(1+e^{-w^Tx^{(i)}}) \\tag{10}\\\\\\ \\end{align} \\end{split}$$ \n",
    "\n",
    "同理，来看  $ \\log(1-h_{w}(x^{(i)}))$  ： \n",
    "\n",
    "$$\\begin{split} \\begin{align} \\log(1-h_{w}(x^{(i)})) & = \\log(1-\\frac{1}{1+e^{-w^Tx^{(i)}}})\\\\\\ & = \\log(\\frac{e^{-w^Tx^{(i)}}}{1+e^{-w^Tx^{(i)}}})\\\\\\ & = \\log(e^{-w^Tx^{(i)}})-\\log(1+e^{-w^Tx^{(i)}})\\\\\\ & = -w^Tx^{(i)}-\\log(1+e^{-w^Tx^{(i)}}) \\tag{11}\\\\\\ \\end{align} \\end{split}$$ \n",
    "\n",
    "将式  $(10)$  和式  $(11)$  带入式  $(9)$  并化简得： \n",
    "\n",
    "$$\\begin{split} \\begin{align} J(w) & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ y^{(i)} (-\\log(1+e^{-w^Tx^{(i)}})) + (1-y^{(i)})(-w^Tx^{(i)}-\\log(1+e^{-w^Tx^{(i)}}))\\right ] \\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ - y^{(i)}\\log(1+e^{-w^Tx^{(i)}}) - w^Tx^{(i)}-\\log(1+e^{-w^Tx^{(i)}})+w^Tx^{(i)}y^{(i)}+y^{(i)}\\log(1+e^{-w^Tx^{(i)}})\\right ]\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [- w^Tx^{(i)}-\\log(1+e^{-w^Tx^{(i)}})+w^Tx^{(i)}y^{(i)} \\right ]\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [-\\log(e^{w^Tx^{(i)}})-\\log(1+e^{-w^Tx^{(i)}})+w^Tx^{(i)}y^{(i)} \\right ]\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [-\\log(e^{w^Tx^{(i)}}(1+e^{-w^Tx^{(i)}}))+w^Tx^{(i)}y^{(i)} \\right ]\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [-\\log(e^{w^Tx^{(i)}}+1)+w^Tx^{(i)}y^{(i)} \\right ] \\tag{12}\\\\\\ \\end{align} \\end{split}$$ \n",
    "\n",
    "现在对式  $(12)$  求导得： \n",
    "\n",
    "$$\\begin{split} \\begin{align} \\frac{\\partial{J}}{\\partial{w}} & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ - \\frac{x^{(i)}e^{w^Tx^{(i)}}}{e^{w^Tx^{(i)}}+1}+x^{(i)}y^{(i)}\\right ]\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ - \\frac{e^{w^Tx^{(i)}}}{e^{w^Tx^{(i)}}+1}+y^{(i)}\\right ]x^{(i)}\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ - \\frac{e^{-w^Tx^{(i)}}e^{w^Tx^{(i)}}}{e^{-w^Tx^{(i)}}(e^{w^Tx^{(i)}}+1)}+y^{(i)}\\right ]x^{(i)}\\\\\\ & = -\\frac{1}{m} \\sum_{i=1}^m \\left [ - \\frac{1}{1+e^{-w^Tx^{(i)}}}+y^{(i)}\\right ]x^{(i)}\\tag{13}\\\\\\ \\end{align} \\end{split}$$ \n",
    "\n",
    "将式  $(4)$  带入式  $(13)$  得： \n",
    "\n",
    "$$ \\frac{\\partial{J}}{\\partial{w}}= -\\frac{1}{m} \\sum_{i=1}^m \\left [ - h_w(x^{(i)})+y^{(i)}\\right ]x^{(i)} \\tag{14} $$ \n",
    "\n",
    "为了便于理解，将式  $(14)$  用向量的形式表达得： \n",
    "\n",
    "$$ \\frac{\\partial{J}}{\\partial{w}} = \\frac{1}{m}x^T(h_{w}(x)-y) \\tag{15} $$ \n",
    "\n",
    "当我们得到梯度的方向，然后乘以一个常数  $\\alpha$  ，就可以得到每次梯度下降的步长(上图箭头的长度)。最后，通过多次迭代，找到梯度变化很小的点，也就对应着损失函数的极小值了。其中，常数  $\\alpha$  往往也被称之为学习率 Learning Rate。执行权重更新的过程为： \n",
    "\n",
    "$$ w \\leftarrow w - \\alpha \\frac{\\partial{J}}{\\partial{w}} \\tag{16} $$ \n",
    "\n",
    "下面，我们用代码实现公式  $(15)$  ： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "723c7fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient(X, h, y):\n",
    "    gradient = np.dot(X.T, (h - y)) / y.shape[0]\n",
    "    return gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5db01844",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  10.9.  逻辑回归 Python 实现  # \n",
    "\n",
    "实验到目前为止，我们已经具备了实施逻辑回归的基本要素。接下来，就通过一组示例数据，使用逻辑回归完成分类任务。首先，下载并加载示例数据。数据集名称为： ` course-8-data.csv  ` 。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8a866ff8",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3388776020.py, line 1)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[17]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mwget -nc https://cdn.aibydoing.com/aibydoing/files/course-8-data.csv\u001b[39m\n             ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "wget -nc https://cdn.aibydoing.com/aibydoing/files/course-8-data.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f97d0a56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X0</th>\n",
       "      <th>X1</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    X0   X1  Y\n",
       "0  5.1  3.5  0\n",
       "1  4.9  3.0  0\n",
       "2  4.7  3.2  0\n",
       "3  4.6  3.1  0\n",
       "4  5.0  3.6  0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(\"../../data/course-8-data.csv\", header=0,)  # 加载数据集\n",
    "df.head()  # 预览前 5 行数据"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a10af457",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "可以看到，该数据集共有两个特征变量 X0 和 X1, 以及一个目标值 Y。其中，目标值 Y 只包含 0 和 1，也就是一个典型的 0-1 分类问题。我们尝试将该数据集绘制成图，看一看数据的分布情况。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faa8b58d",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x2353abfcf50>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df[\"X0\"], df[\"X1\"], c=df[\"Y\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c15a7d",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "面对上图中，深蓝色代表 0，黄色代表 1。接下来，就运用逻辑回归完成对 2 类数据划分。也就是公式  $(3)$  中的线性函数。 \n",
    "\n",
    "为了更方便代码的展示，这里将上面提到的逻辑回归模型、损失函数以及梯度下降的代码集中到一起呈现。接下来，就使用 Python 实现逻辑回归的代码。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70ef7f69",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    # Sigmoid 分布函数\n",
    "    sigmoid = 1 / (1 + np.exp(-z))\n",
    "    return sigmoid\n",
    "\n",
    "def loss(h, y):\n",
    "    # 损失函数\n",
    "    loss = (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()\n",
    "    return loss\n",
    "\n",
    "def gradient(X, h, y):\n",
    "    # 梯度计算\n",
    "    gradient = np.dot(X.T, (h - y)) / y.shape[0]\n",
    "    return gradient\n",
    "\n",
    "def Logistic_Regression(x, y, lr, num_iter):\n",
    "    # 逻辑回归过程\n",
    "    intercept = np.ones((x.shape[0], 1))  # 初始化截距为 1\n",
    "    x = np.concatenate((intercept, x), axis=1)\n",
    "    w = np.zeros(x.shape[1])  # 初始化参数为 0\n",
    "\n",
    "    for i in range(num_iter):  # 梯度下降迭代\n",
    "        z = np.dot(x, w)  # 线性函数\n",
    "        h = sigmoid(z)  # sigmoid 函数\n",
    "\n",
    "        g = gradient(x, h, y)  # 计算梯度\n",
    "        w -= lr * g  # 通过学习率 lr 计算步长并执行梯度下降\n",
    "\n",
    "        l = loss(h, y)  # 计算损失函数值\n",
    "\n",
    "    return l, w  # 返回迭代后的梯度和参数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d55ee102",
   "metadata": {},
   "source": [
    "这段代码实现了一个简单的逻辑回归模型，包括 Sigmoid 函数、损失函数、梯度计算以及逻辑回归的训练过程。以下是逐步解释：\n",
    "\n",
    "---\n",
    "\n",
    "### 1. **Sigmoid 函数**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69c4d5d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    # Sigmoid 分布函数\n",
    "    sigmoid = 1 / (1 + np.exp(-z))\n",
    "    return sigmoid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b39123",
   "metadata": {},
   "source": [
    "- **作用**：将输入 \\( z \\) 映射到 (0, 1) 的范围，常用于将线性输出转化为概率值。\n",
    "- **公式**：\\(\\sigma(z) = \\frac{1}{1 + e^{-z}}\\)\n",
    "- **用途**：在逻辑回归中，用于将线性模型的输出转化为概率。\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **损失函数**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d2e999e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(h, y):\n",
    "    # 损失函数\n",
    "    loss = (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97185d73",
   "metadata": {},
   "source": [
    "- **作用**：计算逻辑回归的损失值，用于衡量模型预测值 \\( h \\) 与真实值 \\( y \\) 的差异。\n",
    "- **公式**：\n",
    "\\[\n",
    "\\text{Loss} = -\\frac{1}{m} \\sum_{i=1}^m \\left[ y_i \\log(h_i) + (1 - y_i) \\log(1 - h_i) \\right]\n",
    "\\]\n",
    "- **用途**：在梯度下降中，优化目标是最小化损失函数。\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **梯度计算**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f882ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient(X, h, y):\n",
    "    # 梯度计算\n",
    "    gradient = np.dot(X.T, (h - y)) / y.shape[0]\n",
    "    return gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05406c11",
   "metadata": {},
   "source": [
    "这段代码实现了逻辑回归中梯度下降法的 **梯度计算**，以下是详细的解释，包括公式推导和代码的对应关系。\n",
    "\n",
    "---\n",
    "\n",
    "### 1. **背景知识**\n",
    "逻辑回归的目标是通过最优化损失函数来找到最优参数。逻辑回归的损失函数通常是 **对数损失函数**，其公式为：\n",
    "\n",
    "$$[\n",
    "J(\\theta) = -\\frac{1}{m} \\sum_{i=1}^m \\left[ y^{(i)} \\log(h_\\theta(x^{(i)})) + (1 - y^{(i)}) \\log(1 - h_\\theta(x^{(i)})) \\right]\n",
    "]\n",
    "$$\n",
    "\n",
    "其中：\n",
    "- \\( m \\)：样本数量。\n",
    "- \\( y^{(i)} \\)：第 \\( i \\) 个样本的真实标签。\n",
    "- \\( h_\\theta(x^{(i)}) \\)：逻辑回归的预测值（即 Sigmoid 函数的输出）。\n",
    "- \\( \\theta \\)：模型参数。\n",
    "\n",
    "为了最小化损失函数 \\( J(\\theta) \\)，我们需要计算其对参数 \\( \\theta \\) 的偏导数（梯度），然后通过梯度下降法更新参数。\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **梯度公式推导**\n",
    "逻辑回归的预测值由 Sigmoid 函数给出：\n",
    "\\[\n",
    "h_\\theta(x) = \\sigma(z) = \\frac{1}{1 + e^{-z}}, \\quad z = X \\cdot \\theta\n",
    "\\]\n",
    "\n",
    "损失函数对参数 \\( \\theta \\) 的偏导数为：\n",
    "\\[\n",
    "\\frac{\\partial J(\\theta)}{\\partial \\theta} = \\frac{1}{m} X^T \\cdot (h - y)\n",
    "\\]\n",
    "\n",
    "其中：\n",
    "- \\( X \\)：输入特征矩阵，形状为 \\( (m, n) \\)，\\( m \\) 是样本数量，\\( n \\) 是特征数量。\n",
    "- \\( h \\)：预测值向量，形状为 \\( (m, 1) \\)，每个元素是 \\( h_\\theta(x^{(i)}) \\)。\n",
    "- \\( y \\)：真实标签向量，形状为 \\( (m, 1) \\)。\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **代码与公式的对应关系**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d918f37a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient(X, h, y):\n",
    "    # 梯度计算\n",
    "    gradient = np.dot(X.T, (h - y)) / y.shape[0]\n",
    "    return gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6313d0",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "#### 对应公式：\n",
    "\\[\n",
    "\\frac{\\partial J(\\theta)}{\\partial \\theta} = \\frac{1}{m} X^T \\cdot (h - y)\n",
    "\\]\n",
    "\n",
    "- **`X.T`**：\n",
    "  - 表示特征矩阵 \\( X \\) 的转置，形状从 \\( (m, n) \\) 变为 \\( (n, m) \\)。\n",
    "  - 转置是为了实现矩阵乘法 \\( X^T \\cdot (h - y) \\)，结果是一个形状为 \\( (n, 1) \\) 的梯度向量。\n",
    "\n",
    "- **`(h - y)`**：\n",
    "  - 表示预测值 \\( h \\) 与真实标签 \\( y \\) 的差值，形状为 \\( (m, 1) \\)。\n",
    "  - 这是逻辑回归中梯度的核心部分，表示预测误差。\n",
    "\n",
    "- **`np.dot(X.T, (h - y))`**：\n",
    "  - 计算 \\( X^T \\cdot (h - y) \\)，结果是一个形状为 \\( (n, 1) \\) 的向量，表示每个参数的梯度。\n",
    "\n",
    "- **`/ y.shape[0]`**：\n",
    "  - 将梯度除以样本数量 \\( m \\)，实现梯度的平均化。\n",
    "\n",
    "#### 为什么公式中没有指数？\n",
    "- 指数 \\( e^{-z} \\) 是 Sigmoid 函数的一部分，但在梯度公式中已经被简化。\n",
    "- 通过对 Sigmoid 函数的导数进行推导，可以得到：\n",
    "  \\[\n",
    "  \\frac{\\partial \\sigma(z)}{\\partial z} = \\sigma(z) \\cdot (1 - \\sigma(z))\n",
    "  \\]\n",
    "  这部分已经隐含在 \\( h - y \\) 中，因此代码中不需要显式地体现指数。\n",
    "\n",
    "---\n",
    "\n",
    "### 4. **梯度计算的作用**\n",
    "梯度表示损失函数对每个参数的变化率，用于更新参数：\n",
    "\\[\n",
    "\\theta = \\theta - \\alpha \\cdot \\frac{\\partial J(\\theta)}{\\partial \\theta}\n",
    "\\]\n",
    "其中：\n",
    "- \\( \\alpha \\)：学习率。\n",
    "- \\( \\frac{\\partial J(\\theta)}{\\partial \\theta} \\)：梯度。\n",
    "\n",
    "---\n",
    "\n",
    "### 5. **总结**\n",
    "- 这段代码实现了逻辑回归中梯度的计算，核心公式为：\n",
    "  \\[\n",
    "  \\frac{\\partial J(\\theta)}{\\partial \\theta} = \\frac{1}{m} X^T \\cdot (h - y)\n",
    "  \\]\n",
    "- 指数 \\( e^{-z} \\) 已经在 Sigmoid 函数的计算中被隐式处理，梯度公式中不需要显式体现。\n",
    "- 梯度用于更新模型参数，使损失函数逐步减小，最终找到最优解。\n",
    "\n",
    "Similar code found with 1 license type"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b0bb6ba",
   "metadata": {},
   "source": [
    "- **作用**：计算损失函数对模型参数的梯度，用于更新参数。\n",
    "- **公式**：\n",
    "\\[\n",
    "\\text{Gradient} = \\frac{1}{m} X^T (h - y)\n",
    "\\]\n",
    "- **用途**：在梯度下降中，用梯度更新模型参数。\n",
    "\n",
    "---\n",
    "\n",
    "### 4. **逻辑回归训练过程**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "808cee8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Logistic_Regression(x, y, lr, num_iter):\n",
    "    # 逻辑回归过程\n",
    "    intercept = np.ones((x.shape[0], 1))  # 初始化截距为 1\n",
    "    x = np.concatenate((intercept, x), axis=1)\n",
    "    w = np.zeros(x.shape[1])  # 初始化参数为 0\n",
    "\n",
    "    for i in range(num_iter):  # 梯度下降迭代\n",
    "        z = np.dot(x, w)  # 线性函数\n",
    "        h = sigmoid(z)  # sigmoid 函数\n",
    "\n",
    "        g = gradient(x, h, y)  # 计算梯度\n",
    "        w -= lr * g  # 通过学习率 lr 计算步长并执行梯度下降\n",
    "\n",
    "        l = loss(h, y)  # 计算损失函数值\n",
    "\n",
    "    return l, w  # 返回迭代后的梯度和参数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af902ca",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "#### 详细解释：\n",
    "1. **初始化**：\n",
    "   - `intercept`：为输入数据 \\( x \\) 添加一列全为 1 的截距项。\n",
    "   - `w`：初始化权重参数为 0。\n",
    "\n",
    "2. **梯度下降迭代**：\n",
    "   - **线性函数**：计算 \\( z = X \\cdot w \\)，即模型的线性输出。\n",
    "   - **Sigmoid 函数**：将线性输出 \\( z \\) 转化为概率 \\( h \\)。\n",
    "   - **梯度计算**：调用 `gradient` 函数，计算损失函数对参数的梯度。\n",
    "   - **参数更新**：使用学习率 \\( lr \\) 和梯度 \\( g \\) 更新参数 \\( w \\)。\n",
    "   - **损失计算**：调用 `loss` 函数，计算当前迭代的损失值。\n",
    "\n",
    "3. **返回结果**：\n",
    "   - 返回最终的损失值 \\( l \\) 和训练好的权重参数 \\( w \\)。\n",
    "\n",
    "---\n",
    "\n",
    "### 总结\n",
    "这段代码实现了逻辑回归的核心流程：\n",
    "1. **Sigmoid 函数**：将线性输出转化为概率。\n",
    "2. **损失函数**：衡量模型预测与真实值的差异。\n",
    "3. **梯度下降**：通过梯度更新参数，最小化损失函数。\n",
    "\n",
    "最终，`Logistic_Regression` 函数返回训练好的模型参数 \\( w \\) 和最终的损失值 \\( l \\)。\n",
    "\n",
    "Similar code found with 2 license types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be0cebdb",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "然后，我们设定学习率和迭代次数，对数据进行训练。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6ebd2b9f",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(np.float64(0.05103697443193301),\n",
       " array([-1.47673791,  4.27250311, -6.9234085 ]))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = df[[\"X0\", \"X1\"]].values\n",
    "y = df[\"Y\"].values\n",
    "lr = 0.01  # 学习率\n",
    "num_iter = 30000  # 迭代次数\n",
    "\n",
    "# 训练\n",
    "L = Logistic_Regression(x, y, lr, num_iter)\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91f27e6e",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "根据我们计算得到的权重，分类边界线的函数为： \n",
    "\n",
    "$$ y=L[1][0]+L[1][1] * x^1+L[1][2] * x^2 $$ \n",
    "\n",
    "$L[*][*]$  是从  $L$  数组中选择相应取值。 \n",
    "\n",
    "有了分类边界线函数，我们就可以将其绘制到原图中，看一看分类的效果到底如何。下面这段绘图代码涉及到 Matplotlib 绘制轮廓线，不需要掌握。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "41f3210e",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x2354d894b50>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df[\"X0\"], df[\"X1\"], c=df[\"Y\"])\n",
    "\n",
    "x1_min, x1_max = (\n",
    "    df[\"X0\"].min(),\n",
    "    df[\"X0\"].max(),\n",
    ")\n",
    "x2_min, x2_max = (\n",
    "    df[\"X1\"].min(),\n",
    "    df[\"X1\"].max(),\n",
    ")\n",
    "\n",
    "xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))\n",
    "grid = np.c_[xx1.ravel(), xx2.ravel()]\n",
    "\n",
    "probs = (np.dot(grid, np.array([L[1][1:3]]).T) + L[1][0]).reshape(xx1.shape)\n",
    "plt.contour(xx1, xx2, probs, levels=[0], linewidths=1, colors=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb7d41e1",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "可以看出，上图中红线代表我们得到的分割线，也就是线性函数。它比较符合两类数据的分离趋势。 \n",
    "\n",
    "除了绘制决策边界，也就是分割线。我们也可以将损失函数的变化过程绘制处理，看一看梯度下降的执行过程。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "829567fd",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Loss function')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAINCAYAAAAJGy/3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAU01JREFUeJzt3Ql4VOXZ//F7su8LhCQEwr6JyL4IimhFsVqVupRaWyharbhURfsKtYLia3GplqpUqq1CW/+Ku74uuCAoKIoFUVH2NUBWlqxkm5n/dT+TGRKyQ5JzJvP9XNfxrDPzTI6TzI/nOfdxuN1utwAAAAAA6hVU/y4AAAAAgCI4AQAAAEAjCE4AAAAA0AiCEwAAAAA0guAEAAAAAI0gOAEAAABAIwhOAAAAANAIghMAAAAANCJEAozL5ZIDBw5IbGysOBwOq5sDAAAAwCJut1sKCwslLS1NgoIa7lMKuOCkoSk9Pd3qZgAAAACwiYyMDOnatWuDxwRccNKeJu8PJy4uzurmAAAAALBIQUGB6VTxZoSGBFxw8g7P09BEcAIAAADgaMIlPBSHAAAAAIBGEJwAAAAAoBEEJwAAAABoBMEJAAAAABpBcAIAAACARhCcAAAAAKARBCcAAAAAaATBCQAAAAAaQXACAAAAAH8ITgsXLpQePXpIRESEjBkzRtauXVvvsWeffba5s+/x00UXXdSmbQYAAAAQOCwPTkuXLpWZM2fK3LlzZf369TJkyBCZNGmS5OTk1Hn8a6+9JpmZmb5p48aNEhwcLFdeeWWbtx0AAABAYLA8OD322GNy3XXXyfTp02XgwIGyaNEiiYqKkmeffbbO4zt06CCpqam+6cMPPzTHE5wAAAAAtMvgVF5eLuvWrZOJEycea1BQkFlfs2ZNk57jn//8p/z85z+X6OjoOveXlZVJQUFBjQkAAAAA/CY45eXlidPplJSUlBrbdT0rK6vRx+u1UDpU7ze/+U29x8yfP1/i4+N9U3p6eou0HQAAAEDgsHyo3snQ3qbTTjtNRo8eXe8xs2fPlvz8fN+UkZHRpm0EAAAA4P9CrHzxpKQkU9ghOzu7xnZd1+uXGlJcXCwvvviizJs3r8HjwsPDzQQAAAAAftnjFBYWJiNGjJDly5f7trlcLrM+duzYBh/78ssvm+uXfvnLX4q/2pxVIO99lymbMrnuCgAAALAzy4fqaSnyZ555RpYsWSKbNm2SGTNmmN4krbKnpk6daobb1TVMb/LkydKxY0fxV6+t3y8znl8vr63fZ3VTAAAAANh1qJ6aMmWK5Obmypw5c0xBiKFDh8qyZct8BSP27t1rKu1Vt2XLFlm9erV88MEH4s8cVXO32+KGAAAAALB3cFI333yzmeqycuXKWtv69+8v7vaQNqqSUzt4JwAAAEC7ZvlQvUAW5PAkp/aQAQEAAID2jOBkh6F69DkBAAAAtkZwslBVhxM9TgAAAIDNEZws5Kjqc2oX12sBAAAA7RjByQ49TlY3BAAAAECDCE4Wohw5AAAA4B8IThZyeKvq0ecEAAAA2BrByUIUhwAAAAD8A8HJDsUhrG4IAAAAgAYRnGzR40R0AgAAAOyM4GQhikMAAAAA/oHgZCGucQIAAAD8A8HJQlTVAwAAAPwDwclC9DgBAAAA/oHgZCGq6gEAAAD+geBkIXqcAAAAAP9AcLJFVT2SEwAAAGBnBCc79DhZ3RAAAAAADSI42eEaJ3qcAAAAAFsjOFmIHicAAADAPxCc7HAfJ5ITAAAAYGsEJzsUh7C4HQAAAAAaRnCyRTlyohMAAABgZwQnW5Qjt7ghAAAAABpEcLLDNU4M1gMAAABsjeBkoSDfUD2rWwIAAACgIQQnK1FVDwAAAPALBCdbVNUjOQEAAAB2RnCyRVU9q1sCAAAAoCEEJws5qvqcyE0AAACAvRGcLMR9nAAAAAD/QHCyEFX1AAAAAP9AcLIQQ/UAAAAA/0BwshJD9QAAAAC/QHCyRTlyAAAAAHZGcLKQgxvgAgAAAH6B4GSDHicXyQkAAACwNYKThYL46QMAAAB+ga/udqiqR4cTAAAAYGsEJzvcAJfyEAAAAICtEZxsgB4nAAAAwN4IThaiqh4AAADgHwhOtriPE8kJAAAAsDOCk4WCqnqcXOQmAAAAwNYITjYoDkGHEwAAAGBvBCcLhQR5klOFy2V1UwAAAAA0gOBkodAQz4+/wklwAgAAAOyM4GSh8OCq4FTJWD0AAADAzghONuhxKqfHCQAAALA1gpOFwqp6nMorCU4AAACAnRGcLBTqDU70OAEAAAC2RnCyUFhIVVU9ghMAAABgawQnC4UFB5t5BUP1AAAAAFsjOFkotKrHiaF6AAAAgL1ZHpwWLlwoPXr0kIiICBkzZoysXbu2weOPHDkiN910k3Tu3FnCw8OlX79+8u6774o/igip6nFyuhmuBwAAANhYiJUvvnTpUpk5c6YsWrTIhKYFCxbIpEmTZMuWLZKcnFzr+PLycjnvvPPMvldeeUW6dOkie/bskYSEBPFHsRHHfvyFpZXSITrM0vYAAAAAsGFweuyxx+S6666T6dOnm3UNUO+88448++yzMmvWrFrH6/ZDhw7J559/LqGhoWab9lb5q5DgIIkOC5bicqcUHK0gOAEAAAA2ZdlQPe09WrdunUycOPFYY4KCzPqaNWvqfMxbb70lY8eONUP1UlJSZNCgQfKnP/1JnE6n+Ku4yFBfjxMAAAAAe7KsxykvL88EHg1A1en65s2b63zMzp075eOPP5arr77aXNe0fft2ufHGG6WiokLmzp1b52PKysrM5FVQUCB2EhcRKpn5pVJQWmF1UwAAAADYtThEc7hcLnN909NPPy0jRoyQKVOmyN13322G+NVn/vz5Eh8f75vS09PFTuIiPdlVh+oBAAAAsCfLglNSUpIEBwdLdnZ2je26npqaWudjtJKeVtHTx3mdcsopkpWVZYb+1WX27NmSn5/vmzIyMsRuPU6KHicAAADAviwLTmFhYabXaPny5TV6lHRdr2OqyxlnnGGG5+lxXlu3bjWBSp+vLlqyPC4ursZkx8p6+fQ4AQAAALZl6VA9LUX+zDPPyJIlS2TTpk0yY8YMKS4u9lXZmzp1qukx8tL9WlXv1ltvNYFJK/BpcQgtFuGvEqI8ge9ICcEJAAAAsCtLy5HrNUq5ubkyZ84cM9xu6NChsmzZMl/BiL1795pKe156fdL7778vt99+uwwePNjcx0lD1F133SX+KiHKM1TvCD1OAAAAgG053G63WwKIVtXTIhF6vZMdhu0t+Xy3zH3re7nwtFT529UjrG4OAAAAEDAKmpEN/KqqXnvk7XE6XEyPEwAAAGBXBCeLJVZd43S4pO6qgAAAAACsR3CySXCiOAQAAABgXwQnuwzVo8cJAAAAsC2Ck02CU1mlS46WO61uDgAAAIA6EJwsFhMeIiFBDrNMrxMAAABgTwQnizkcDt9NcAlOAAAAgD0RnGwg0XsTXApEAAAAALZEcLIBSpIDAAAA9kZwslVlPXqcAAAAADsiONnpXk7F9DgBAAAAdkRwsoGEaHqcAAAAADsjONmpx4lrnAAAAABbIjjZqKoexSEAAAAAeyI42cCx+zgxVA8AAACwI4KTDTBUDwAAALA3gpOthurR4wQAAADYEcHJRkP1CkorxOlyW90cAAAAAMchONmA9wa4brdI/lF6nQAAAAC7ITjZQGhwkMSEh5hlrnMCAAAA7IfgZLNeJ65zAgAAAOyH4GSzynqHi+lxAgAAAOyG4GQTHaI9wekQQ/UAAAAA2yE42URHb3CixwkAAACwHYKT3XqcCE4AAACA7RCcbKJDjCc45RWVWd0UAAAAAMchONlEUnS4mdPjBAAAANgPwckmGKoHAAAA2BfByWZD9Q4WEZwAAAAAuyE42QRV9QAAAAD7IjjZRMcYzzVORyucUlJeaXVzAAAAAFRDcLKJ6LBgCQvxnA6G6wEAAAD2QnCyCYfDwXA9AAAAwKYITjZCZT0AAADAnghONrzOiZvgAgAAAPZCcLIRhuoBAAAA9kRwshGG6gEAAAD2RHCyYXA6SHACAAAAbIXgZCNJMfQ4AQAAAHZEcLKRDtGe4hAHKQ4BAAAA2ArByUYYqgcAAADYE8HJRqiqBwAAANgTwclGOlZd41RS7pSj5U6rmwMAAACgCsHJRmLCQyQs2HNKDhZznRMAAABgFwQnG3E4HNzLCQAAALAhgpNNh+sdLCI4AQAAAHZBcLKZpBhPSfJcSpIDAAAAtkFwsplOsZ7glEdwAgAAAGyD4GTT4JRbSHACAAAA7ILgZDOdvEP1CE4AAACAbRCcbIYeJwAAAMB+CE52DU5c4wQAAADYBsHJrlX16HECAAAAbIPgZNMep8LSSimtcFrdHAAAAAAEJ/uJiwiRsBDPaaHXCQAAALAHWwSnhQsXSo8ePSQiIkLGjBkja9eurffYxYsXi8PhqDHp49oLfT++ynpc5wQAAADYguXBaenSpTJz5kyZO3eurF+/XoYMGSKTJk2SnJyceh8TFxcnmZmZvmnPnj3SnlBZDwAAALAXy4PTY489Jtddd51Mnz5dBg4cKIsWLZKoqCh59tlnG+yVSU1N9U0pKSnSnhCcAAAAAHuxNDiVl5fLunXrZOLEiccaFBRk1tesWVPv44qKiqR79+6Snp4ul156qXz//ff1HltWViYFBQU1JrsjOAEAAAD2YmlwysvLE6fTWavHSNezsrLqfEz//v1Nb9Sbb74p//nPf8Tlcsm4ceNk3759dR4/f/58iY+P900atuzOe41THtc4AQAAALZg+VC95ho7dqxMnTpVhg4dKhMmTJDXXntNOnXqJH//+9/rPH727NmSn5/vmzIyMsTu6HECAAAA7CXEyhdPSkqS4OBgyc7OrrFd1/XapaYIDQ2VYcOGyfbt2+vcHx4ebia/vAkuPU4AAACALVja4xQWFiYjRoyQ5cuX+7bp0Dtd156lptChft9995107txZ2gt6nAAAAAB7sbTHSWkp8mnTpsnIkSNl9OjRsmDBAikuLjZV9pQOy+vSpYu5VknNmzdPTj/9dOnTp48cOXJEHnnkEVOO/De/+Y20F8nVgpPb7TZVBAEAAAAEcHCaMmWK5Obmypw5c0xBCL12admyZb6CEXv37jWV9rwOHz5sypfrsYmJiabH6vPPPzelzNsL71C9skqXFJZVSlxEqNVNAgAAAAKaw61dGgFEy5FrdT0tFKE30rWr0+a+b0LT8jsmSO9OMVY3BwAAAAjobOB3VfUChfc6p5wCrnMCAAAArEZwsntwKiy1uikAAABAwCM42VRqfISZZ+UTnAAAAACrEZxsKjWuKjgVEJwAAAAAqxGcbCqlKjhxjRMAAABgPYKT3Yfq0eMEAAAAWI7gZPMeJ65xAgAAAKxHcLJ5j5NW1XO5AupWWwAAAIDtEJxsKjk2XBwOkQqnWw6VlFvdHAAAACCgEZxsKjQ4SDpGe+7lxHA9AAAAwFoEJxtLifMEp2wKRAAAAACWIjj5wb2csilJDgAAAFiK4GRjKZQkBwAAAGyB4OQPPU5c4wQAAABYiuDkB8GJHicAAADAWgQnPxiqR3EIAAAAwFoEJxujxwkAAACwB4KTHwSnIyUVUlrhtLo5AAAAQMAiONlYXGSIRIR6ThHD9QAAAADrEJxszOFwSIp3uB6V9QAAAADLEJxsLi0+0swzCU4AAACAZQhONpeW4AlO+48ctbopAAAAQMAiONlclwTPUL0DBCcAAADAMgQnP+lxIjgBAAAA1iE42RxD9QAAAADrEZz8JTgdPiput9vq5gAAAAABieBkc2lV1zgVlzuloLTS6uYAAAAAAYngZHNRYSHSITrMLHOdEwAAAGANgpMf9ToRnAAAAABrEJz86Ca4BCcAAADAGgQnPyoQsY/gBAAAAFiC4OQHuvju5VRqdVMAAACAgERw8gPcBBcAAACwVsiJPMjlcsn27dslJyfHLFd31llntVTbUIXiEAAAAICfBacvvvhCfvGLX8iePXtq3ZDV4XCI0+lsyfah2lC97IJSqXC6JDSYjkIAAADA1sHphhtukJEjR8o777wjnTt3NmEJrSspJlzCgoOk3Oky4alrYpTVTQIAAAACSrOD07Zt2+SVV16RPn36tE6LUEtQkEM6J0TInoMlsv/wUYITAAAA0MaaPeZrzJgx5vomtK2uiVUlyQ9znRMAAABg+x6nW265Re644w7JysqS0047TUJDQ2vsHzx4cEu2D1XSTS/TQdl7qMTqpgAAAAABp9nB6fLLLzfza665xrdNr3PSQhEUh2g96R08w/MyCE4AAACA/YPTrl27WqclaFC3quBEjxMAAADgB8Gpe/furdMSNCk4ZRwmOAEAAAB+cQPcHTt2yIIFC2TTpk1mfeDAgXLrrbdK7969W7p9OC44ZReUSWmFUyJCg61uEgAAABAwml1V7/333zdBae3ataYQhE5ffvmlnHrqqfLhhx+2TishCVGhEhPuybn76HUCAAAA7N3jNGvWLLn99tvlwQcfrLX9rrvukvPOO68l24cqWnhDC0Rsyiww1zn1SY61ukkAAABAwGh2j5MOz7v22mtrbdcqez/88ENLtQt16NbBcy+njEPcywkAAACwdXDq1KmTbNiwodZ23ZacnNxS7UIdqKwHAAAA+MlQveuuu06uv/562blzp4wbN85s++yzz+Shhx6SmTNntkYbUYXgBAAAAPhJcLrnnnskNjZWHn30UZk9e7bZlpaWJvfee6/87ne/a402okpXboILAAAA+Edw0iIFWhxCp8LCQrNNgxTa8F5Oh0rE7XabcwEAAADApvdx8iIwta0uCZGiWam43CmHisulY0y41U0CAAAAAkKTgtPw4cNl+fLlkpiYKMOGDWuwp2P9+vUt2T5Uoze9TY2LkMz8UnOdE8EJAAAAsFFwuvTSSyU8PNy3zBAx6+i9nLzBaVi3RKubAwAAAASEJgWnuXPn+pa1CASs07NjtKzddUh25RVb3RQAAAAgYDT7Pk69evWSgwcP1tp+5MgRs+9ELFy4UHr06CEREREyZswYWbt2bZMe9+KLL5rer8mTJ0ug6Nkp2swJTgAAAICNg9Pu3bvF6XTW2l5WVib79u1rdgOWLl1q7v+kvVp6fdSQIUNk0qRJkpOT02g77rzzThk/frwEkp5JBCcAAADAtlX13nrrLd/y+++/L/Hx8b51DVJaPKJnz57NbsBjjz1mbqo7ffp0s75o0SJ555135Nlnn5VZs2bV+Rh9vauvvlruu+8+WbVqlentChS9vMEpt5iS5AAAAIDdgpN3OJx+UZ82bVqNfaGhoWaond4UtznKy8tl3bp1vhvpqqCgIJk4caKsWbOm3sfNmzdPkpOT5dprrzXBqSHaE6aTV0FBgfizbh2jTEnywrJKySsql06xVNYDAAAAbBOcXC6XmWuv0ldffSVJSUkn/eJ5eXmm9yglJaXGdl3fvHlznY9ZvXq1/POf/5QNGzY06TXmz59veqbai/CQYOmaGCkZh46a4XoEJwAAAMCG1zjt2rWrRULTiSgsLJRf/epX8swzzzS5DdqblZ+f75syMjLE3/Xo6Bmut5vrnAAAAAB79Th5/e53v5M+ffqYeXVPPvmkbN++XRYsWNDk59LwExwcLNnZ2TW263pqamqt43fs2GGKQlx88cW1esJCQkJky5Yt0rt37xqP0ftPee9B1Z6uc1q1LU92EpwAAAAAe/Y4vfrqq3LGGWfU2j5u3Dh55ZVXmvVcYWFhMmLECFNYonoQ0vWxY8fWOn7AgAHy3XffmWF63umSSy6Rc845xyynp6dLYFXWK7K6KQAAAEBAaHaPk97DqXpFPa+4uDhzzVJzaSlyLTYxcuRIGT16tOmxKi4u9lXZmzp1qnTp0sVcq6T3eRo0aFCNxyckJJj58dvbs56dYsyckuQAAACATYOTDtNbtmyZ3HzzzTW2v/feeyd0A9wpU6ZIbm6uzJkzR7KysmTo0KHm+b0FI/bu3Wsq7aF2SfLdB0vE6XJLcBAlyQEAAABbBSftIdLQpGHnRz/6kdmmQ+u0FHlzrm+qTp/v+CDmtXLlygYfu3jxYgk0aQmREhYcJOWVLjlw5Kikd4iyukkAAABAu9bs4HTNNdeY+yI98MADcv/995tteg+np556ygyrQ+vTHia9n9P2nCLZfbCY4AQAAAC0shMaAzdjxgzZt2+fqX6nN5TduXMnocmiAhE7cigQAQAAALS2k7p4qFOnThIT4ylUgLbVJ9nzc9+eS3ACAAAAbBectJdJb0KblpZm7p2k92GqPqFt9K0KTtuyCU4AAACA7a5x+vWvf20q3d1zzz3SuXNncTio6GaFfimxZq7XOQEAAACwWXBavXq1rFq1ypQNh3V6d4oRzawHi8vlYFGZdIwJt7pJAAAAQLvV7KF66enp4na7W6c1aLLIsGDpmhhplrfR6wQAAADYKzjpvZpmzZolu3fvbp0Wocn6JnuG6xGcAAAAAJsN1ZsyZYqUlJRI7969JSoqSkJDQ2vsP3ToUEu2D40UiPh4c45szy60uikAAABAuxZyIj1OsFdJcnqcAAAAAJsFp2nTprVOS9Bsfasq622lJDkAAABgr+Ckpcgb0q1bt5NpD06gxymvqEwOF5dLYnSY1U0CAAAA2qVmB6cePXo0eO8mp9N5sm1CE8WEh0iXhEjZf+SobM8tklHRHaxuEgAAANAuNTs4ff311zXWKyoqzLbHHntMHnjggZZsG5rY66TBaVt2kYzqQXACAAAAbBGchgwZUmvbyJEjJS0tTR555BG57LLLWqptaGJlvU+25spWKusBAAAA9rmPU3369+8vX331VUs9HZrolM5xZv5DZoHVTQEAAADarWb3OBUU1PyC7na7JTMzU+69917p27dvS7YNzQhOmzILzLlo6PozAAAAAG0UnBISEmp9Odcv7Onp6fLiiy+eYDNwMtc4hQY7pLC00lzr1DUxyuomAQAAAO1Os4PTihUraqwHBQVJp06dpE+fPhIS0uynw0kKCwmS3p1iZHNWoWzKLCQ4AQAAAK2gSUln+PDhsnz5cklMTJRPPvlE7rzzTomK4gu6XQzsHFcVnArkvIEpVjcHAAAACMziEJs2bZLi4mKzfN999/mWYb/rnAAAAABY1OM0dOhQmT59upx55pnmeiYtOx4TE1PnsXPmzGnpNqIRBCcAAADABsFp8eLFMnfuXHn77bdNYYj33nuvzuuZdB/Bqe2d0jnWzPccKpHiskqJDudaMwAAAKAlhTT1Hk3einlaDEKvd0pOTm7RhuDEdYwJl+TYcMkpLDPXOo3onmh1kwAAAIDAvgGuy+UiNNkQw/UAAAAAGwUn2NPANIITAAAA0FoITu2oJLnaeIDgBAAAALQ0glM7MbhrvK/HqbzSZXVzAAAAgHaF4NROdOsQJfGRoSY0bc0utLo5AAAAQGAHp4yMDNm3b59vfe3atXLbbbfJ008/3dJtQzNoKXhvr9O3+/Ktbg4AAAAQ2MHpF7/4haxYscIsZ2VlyXnnnWfC09133y3z5s1rjTaiiU7r4glO3+0/YnVTAAAAgMAOThs3bpTRo0eb5ZdeekkGDRokn3/+uTz//PPmRrmwDj1OAAAAgE2CU0VFhYSHh5vljz76SC655BKzPGDAAMnMzGz5FqLJBndNMPMtWYVSWuG0ujkAAABA4AanU089VRYtWiSrVq2SDz/8UC644AKz/cCBA9KxY8fWaCOaqHN8hCTFhEmly839nAAAAAArg9NDDz0kf//73+Xss8+Wq666SoYMGWK2v/XWW74hfLCuQMSx65wYrgcAAAC0lJDmPkADU15enhQUFEhiYqJv+/XXXy9RUVEt1jCcmNO6JsiKLbnyTUa+yFirWwMAAAAEaI/T0aNHpayszBea9uzZIwsWLJAtW7ZIcnJya7QRzTDEVyCCynoAAACAZcHp0ksvlX/9619m+ciRIzJmzBh59NFHZfLkyfLUU0+1WMNwYoakewpEbM8tkvyjFVY3BwAAAAjM4LR+/XoZP368WX7llVckJSXF9DppmHr88cdbo41ohqSYcOneMUrcbpENGfQ6AQAAAJYEp5KSEomNjTXLH3zwgVx22WUSFBQkp59+uglQsN6Ibp5hlOv2HLa6KQAAAEBgBqc+ffrIG2+8IRkZGfL+++/L+eefb7bn5ORIXFxca7QRzTS8uyc4rSc4AQAAANYEpzlz5sidd94pPXr0MOXHx44d6+t9GjZsWMu0CidlRFVw+nrvYXG63FY3BwAAAPB7zS5HfsUVV8iZZ54pmZmZvns4qXPPPVd++tOftnT7cAL6pcRKTHiIFJVVypasQhmYRk8gAAAA0KY9Tio1NdX0Lh04cED27dtntmnv04ABA06qMWgZwUEOGdbNU11v3V6G6wEAAABtHpxcLpfMmzdP4uPjpXv37mZKSEiQ+++/3+yDPQyvKhDBdU4AAACABUP17r77bvnnP/8pDz74oJxxxhlm2+rVq+Xee++V0tJSeeCBB1qgWWip65yorAcAAABYEJyWLFki//jHP+SSSy7xbRs8eLB06dJFbrzxRoKTTQztliAOh8jeQyWSU1gqybERVjcJAAAACJyheocOHarzWibdpvtgD3ERoTIg1VMU4sudnBcAAACgTYOTVtJ78skna23XbdWr7MF6Y3t1NPMvdh60uikAAABAYA3Ve/jhh+Wiiy6Sjz76yHcPpzVr1pgb4r777rut0UacoNN7dZBnP9tFcAIAAADausdpwoQJsnXrVnPPpiNHjpjpsssuky1btsj48eNPtj1oQWN6djTXOe3ILZacglKrmwMAAAAETo+TSktLq1UEQu/ndP3118vTTz/dUm3DSYqPCpWBnePk+wMF8sWuQ3LJkDSrmwQAAAAEzg1w63Lw4EFTphz2cjrXOQEAAAD2CU6weXDaQXACAAAAThTBqZ0b3aODuc5pZ16xZHOdEwAAAOC/wWnhwoXSo0cPiYiIkDFjxsjatWvrPfa1116TkSNHSkJCgkRHR8vQoUPl3//+d5u219+uczo1zXM/J4brAQAAAK1cHEIr5zVEq+udiKVLl8rMmTNl0aJFJjQtWLBAJk2aZKr0JScn1zq+Q4cOcvfdd5sb7oaFhcnbb78t06dPN8fq41DbuN5JsnF/gazalieXDu1idXMAAAAAv+Nwu93uphyo4aQpnnvuuWY1QMPSqFGjfDfVdblckp6eLrfccovMmjWrSc8xfPhwc2+p+++/v9FjCwoKJD4+XvLz8yUuztMT096t2pYrv/rnWkmJC5cvZp8rDh27BwAAAAS4gmZkgyb3ODU3EDVFeXm5rFu3TmbPnu3bFhQUJBMnTjQ31W2MZr6PP/7Y9E499NBDdR5TVlZmpuo/nEAzqkcHiQgNkuyCMtmSXSgDUgMjMAIAAADt4hqnvLw8cTqdkpKSUmO7rmdlZdX7OE2EMTExZqie9jQ98cQTct5559V57Pz5802K9E7amxVoIkKDzc1w1adbc61uDgAAAOB3bFEcorliY2Nlw4YN8tVXX5kb8eo1UitXrqzzWO3N0qDlnTIyMiQQndWvk5l/ujXP6qYAAAAAfqfJQ/VaQ1JSkgQHB0t2dnaN7bqemppa7+N0OF+fPn3MslbV27Rpk+lZOvvss2sdGx4ebqZAN6FfkugVYGt3H5Kj5U6JDAu2ukkAAACA37C0x0mH2o0YMUKWL1/u26bFIXR97NixTX4efUz165hQW+9OMdIlIVLKK13yxS7KkgMAAAB+NVRPh9k988wzsmTJEtNzNGPGDCkuLvZV8Zs6dWqN4hHas/Thhx/Kzp07zfGPPvqouY/TL3/5Swvfhf1pJb2z+iWZZa5zAgAAAPxoqJ6aMmWK5Obmypw5c0xBCB16t2zZMl/BiL1795qheV4aqm688UbZt2+fREZGmvs5/ec//zHPg4ad1beTvLA2Qz7ZkitysdWtAQAAANrhfZzai0C8j5NXYWmFDL//Q6lwumX5HRPM8D0AAAAgUBU0IxtYPlQPbSc2IlRO7+UpS/7RDzULcgAAAACoH8EpwJw/0DME8kOCEwAAANBkBKcAc+4pnuC0bu9hOVhEJUIAAACgKQhOASYtIVIGdYkTvbLt4805VjcHAAAA8AsEpwA0sarXieF6AAAAQNMQnALQeVXXOa3alielFU6rmwMAAADYHsEpAA3sHCddEiLlaIWTm+ECAAAATUBwCkAOh0MuGJRqlt/5LtPq5gAAAAC2R3AKUD8Z3Nl3PyeG6wEAAAANIzgFqKHpCWa4XnG5U1ZuoboeAAAA0BCCUwAP17uoqtfp7W8ZrgcAAAA0hOAUwC46zROclm/KkZLySqubAwAAANgWwSmADe4aL+kdPNX1Vmymuh4AAABQH4JToA/XOy3NLP/fNwesbg4AAABgWwSnAHfJEE9w+nhzjhwpKbe6OQAAAIAtEZwC3MC0ODmlc5yUO130OgEAAAD1IDhBLh/excxfWb/f6qYAAAAAtkRwglw6tIsEBznkm4wjsj2nyOrmAAAAALZDcIJ0ig2Xs/t1Msuvrt9ndXMAAAAA2yE4wbh8RFczf339fnG63FY3BwAAALAVghOMc09JlvjIUMkqKJXV2/Osbg4AAABgKwQnGOEhwfLTYZ4iEc9/scfq5gAAAAC2QnCCz9Vjupn58s05kpl/1OrmAAAAALZBcIJP35RYGd2zg7nGaelXGVY3BwAAALANghPq7HV6cW2GVDpdVjcHAAAAsAWCE2q4YFCqdIwOM0UidMgeAAAAAIIT6igSceXIdLP8H4pEAAAAAAbBCbX8YnQ3cThEVm3Lk23ZhVY3BwAAALAcwQm1dOsYJeedkmKWn/1sl9XNAQAAACxHcEKdrjurl5m/un6/HCwqs7o5AAAAgKUITqjTyO6JMqRrvJRXuuTfXOsEAACAAEdwQp0cDodcO97T6/TvNXuktMJpdZMAAAAAyxCcUK8LB6VKl4RIOVhcLm98vd/q5gAAAACWITihXiHBQTL9jB5m+e+f7uSGuAAAAAhYBCc06KrR3SQxKlR25RXL299mWt0cAAAAwBIEJzQoOjxEflN1rdOTK7aL0+W2ukkAAABAmyM4oVFTx3aXuIgQ2Z5TJO9tpNcJAAAAgYfghEbFRoTKNWf2NMtPfrxdXPQ6AQAAIMAQnNAk08f1lJjwENmcVSjvf59ldXMAAACANkVwQpPER4X6Kuz9+YMtVNgDAABAQCE4ocmuO6uXqbC3I7dYXl2/z+rmAAAAAG2G4IQmi4sIlZvO6WOW//LhNimtcFrdJAAAAKBNEJzQLL88vbukxUdIVkGpLP58t9XNAQAAANoEwQnNEhEaLLef188s/23FdskvqbC6SQAAAECrIzih2S4b3lX6pcRIQWmlLFi+1ermAAAAAK2O4IRmCw5yyD0/GWiW/7Vmj2zNLrS6SQAAAECrIjjhhIzv20nOH5giTpdb7vu/78Xt5qa4AAAAaL8ITjhhf7xooISFBMln2w/K+99nW90cAAAAoNUQnHDCunWMkt+e1css/+87P1CeHAAAAO0WwQknZcbZvaVzfITsO3xUHl++zermAAAAAK2C4ISTEhUWIvdecqpZfvrTnbIps8DqJgEAAAAtjuCEkzbp1FS54NRUqXS5Zdar35qCEQAAAEB7QnBCi7jv0lMlNiJEvtmXL4s/3211cwAAAIAWRXBCi0iJi5DZPz7FLD/6wRbJOFRidZMAAACA9hWcFi5cKD169JCIiAgZM2aMrF27tt5jn3nmGRk/frwkJiaaaeLEiQ0ej7bz81HpMrpnBykpd8odL33DkD0AAAC0G5YHp6VLl8rMmTNl7ty5sn79ehkyZIhMmjRJcnJy6jx+5cqVctVVV8mKFStkzZo1kp6eLueff77s37+/zduOmoKCHPLnK4ZIdFiwrN19SP6xaqfVTQIAAABahMPtdlvaLaA9TKNGjZInn3zSrLtcLhOGbrnlFpk1a1ajj3c6nabnSR8/derURo8vKCiQ+Ph4yc/Pl7i4uBZ5D6jppa8y5H9e/VZCgx3y5k1nysA0fs4AAACwn+ZkA0t7nMrLy2XdunVmuJ2vQUFBZl17k5qipKREKioqpEOHDnXuLysrMz+Q6hNa15Uju8p5A1OkwumWmS9t4Ma4AAAA8HuWBqe8vDzTY5SSklJju65nZWU16TnuuusuSUtLqxG+qps/f75Jkd5Je7PQuhwOh8y/7DRJigmTzVmFMv/dTVY3CQAAAPDva5xOxoMPPigvvviivP7666awRF1mz55tut68U0ZGRpu3MxAlxYTLI1cMMctL1uyRd77NtLpJAAAAgH8Gp6SkJAkODpbs7Owa23U9NTW1wcf++c9/NsHpgw8+kMGDB9d7XHh4uBmvWH1C2zhnQLLMOLu3Wb7r1W9lV16x1U0CAAAA/C84hYWFyYgRI2T58uW+bVocQtfHjh1b7+Mefvhhuf/++2XZsmUycuTINmotTsQd5/WT0T06SFFZpdz4/HqudwIAAIBfsnyonpYi13szLVmyRDZt2iQzZsyQ4uJimT59utmvlfJ0uJ3XQw89JPfcc488++yz5t5Pei2UTkVFRRa+C9QnJDhInvjFMOkYHSabMgvknjc2isWFHAEAAAD/C05Tpkwxw+7mzJkjQ4cOlQ0bNpieJG/BiL1790pm5rHrY5566ilTje+KK66Qzp07+yZ9DthTSlyE/PXnwyTIIfLyun3y7Ge7rW4SAAAA4F/3cWpr3MfJOnpD3P99Z5MJUM9NHy0T+nWyukkAAAAIYAX+ch8nBJZrz+wpV4zoKi63yM3/b73syGV4JQAAAPwDwQlten+nB346SEZ0T5TC0kq5bsl/5XBxudXNAgAAABpFcEKbCg8JlkW/HCFdEiJlZ16xXLvkKzlaTqU9AAAA2BvBCW2uU2y4PDd9lMRFhMj6vUfklhe+lkqny+pmAQAAAPUiOMES/VJi5Z+/HiXhIUHy0aZsuedNypQDAADAvghOsMyoHh3k8as8ZcpfWJshj36w1eomAQAAAHUiOMFSk05NlXmXDjLLT67YLo8v32Z1kwAAAIBaCE6w3C9P7y5/uHCAWX7sw63y1ModVjcJAAAAqIHgBFu4/qze8vtJ/c3yQ8s2m5vlAgAAAHZBcIJt3HROH7n13L5m+X/f2SRPf0rPEwAAAOyB4ARbuW1iX7npnN5m+U/vbpZHP9hCtT0AAABYjuAEW3E4HPL7SQN8w/ae+Hi73Pd/P4jLRXgCAACAdQhOsO2wvXmXnmqWF3++W/7n1W+5SS4AAAAsQ3CCbU0d20Me+9kQCQ5yyCvr9sm1S/4rRWWVVjcLAAAAAYjgBFu7bHhXWfTLERIRGiSfbM2VKxetkcz8o1Y3CwAAAAGG4ATbO29giiy9fqwkxYTJpswC+enCz+WHAwVWNwsAAAABhOAEvzAkPUFev/EM6ZscI1kFpXLlos/l/e+zrG4WAAAAAgTBCX4jvUOUvDJjnIzr3VGKy53y23+vM+XKnVTcAwAAQCsjOMGvxEeGypJrRss1Z/T0lSu/dslXkl9SYXXTAAAA0I4RnOB3QoODZM7FA2XBlKGmaMTKLblyycLVXPcEAACAVkNwgt+aPKyLvHLDOOmSECl7DpbI5L99Jks+3y1uN0P3AAAA0LIITvBrg7rEy9u3nCnnDkiW8kqXzH3re7n+3+vkcHG51U0DAABAO0Jwgt9LjA6Tf0wbKXMvHihhwUHy4Q/ZcuHjq+SLnQetbhoAAADaCYIT2gWHwyHTz+gpr904TnolRUtmfqlc9cwXMu//fpCj5U6rmwcAAAA/R3BCuxu693+3nClTRqaLXur07Ge7TO/Tuj2HrG4aAAAA/BjBCe1OdHiIPHTFYHlu+ihJiQuXXXnFcsWiNfKndzdJaQW9TwAAAGg+ghParXP6J8sHt02Qy4d3Nb1PT3+6UyYt+FQ+2ZprddMAAADgZwhOaNfio0Ll0Z8NkX9MHSmpcRGmbPm0Z9fKzf9vvWQXlFrdPAAAAPgJghMCwsSBKfLRHRPk2jN7SpBD5O1vM+XcRz+RxZ/tkkqny+rmAQAAwOYc7gC7W2hBQYHEx8dLfn6+xMXFWd0cWGDj/ny5+42N8k3GEbPePyVW/viTU2R8305WNw0AAAA2zQYEJwQkp8stL6zdK4+8v0Xyj1aYbT8akCx/uPAU6ZMcY3XzAAAA0AYITg0gOKG6IyXl8tfl2+Tfa/ZIpcstwUEO+eWYbnLrxH7SITrM6uYBAACgFRGcGkBwQl125BbJ/Hc3yUebcsx6THiIXHNmT/nN+J4SFxFqdfMAAADQCghODSA4oSGfbc8z93v6/kCBWY+PDJUbJvSWaeO6S1RYiNXNAwAAQAsiODWA4ITGuFxuWfZ9ljz24VbZnlNktiXFhMtN5/SWq0Z3k4jQYKubCAAAgBZAcGoAwQnNKSDxxtf7ZcHyrZJx6KjZlhQTZobw/fL07gzhAwAA8HMEpwYQnNBc5ZUueXldhjy1cofsO+wJULHhITJ1XHeZfkZP0xsFAAAA/0NwagDBCSeqwumS//vmgPxt5Q7fEL6I0CD52ch0E6B6JkVb3UQAAAA0A8GpAQQntMQ1UB9uypa/rdgu3+zL923X+0BNP6OHnNknSRwOh6VtBAAAQOMITg0gOKGl6Efn8x0H5dnVu2T5Zk8Zc9UvJcb0QE0e2kUiwygkAQAAYFcEpwYQnNAaduUVy5LPd8vL/82Q4nKnr5T5ZcO7mEp8/VJirW4iAAAAjkNwagDBCa2poLRCXvoqQ5as2e2rxKdGdk80AeqiwZ0pZw4AAGATBKcGEJzQVqXMV23LlRfW7pWPNuWYdRUXESKXDe8qV4zoKqemxXEtFAAAgIUITg0gOKGt5RSUysvr9pkQ5S1n7r0W6qfDusrkYWnSOT7S0jYCAAAEogKCU/0ITrCyGt/q7Xmy9KsMU5VP7w+ltNNpXO+OJkRdMChVYsJDrG4qAABAQCggONWP4AQ7yD9aIe99lymvfb1f1u465NseGRpsyppfeFpnOWdAJ4kKI0QBAAC0FoJTAwhOsJuMQyXy5ob9JkTtzC2uEaI0PGmI0jBFiAIAAGhZBKcGEJxgV/pR/G5/vrzzXaa8+11mjap8EaFBcna/ZPnxaalydv9kU+ocAAAAJ4fg1ACCE/yBfiw37i/whai9h0p8+0KCHDK6Zwc595QUmXhKsnTvGG1pWwEAAPwVwakBBCf4G/2Ifn+gwASoD37Ilu05RTX2902O8YWoYd0SJTiIEucAAABNQXBqAMEJ/m7PwWJzb6iPfsiWtbsP+e4RpRKjQuWMPklyVr9OMr5vEmXOAQAAGkBwagDBCe2tOt8nW3NNiFq5JUcKSitr9UZ5Q9SYnh0lMizYsrYCAADYDcGpAQQntFcVTpd8k3FEPt2WJ59uzZVv9x2Rap1REhYSJKN7dJCxvTvK6b06yuCu8RIaHGRlkwEAACxFcGoAwQmB4khJuXy2/aCs2pZrgtSB/NIa+6PCgmVE90QTok7v1UFO65JgwhUAAECgKPCn4LRw4UJ55JFHJCsrS4YMGSJPPPGEjB49us5jv//+e5kzZ46sW7dO9uzZI3/5y1/ktttua9brEZwQiPRjvjOvWFZtzZUvdh6SL3cdlMMlFTWO0ftGjezhCVKjenQwPVIRoQztAwAA7VdzsoGld9RcunSpzJw5UxYtWiRjxoyRBQsWyKRJk2TLli2SnJxc6/iSkhLp1auXXHnllXL77bdb0mbAHzkcDundKcZMvz6jp7hcbtmaUyhf7DgoX+46JF/s9ASpVdvyzOQte35ql3gZ3i3B9EzpRLEJAAAQqCztcdKwNGrUKHnyySfNusvlkvT0dLnllltk1qxZDT62R48epreJHifg5GmQ2pZTZAKUTv/dc1hyC8tqHZcWHyHDNER18wSpUzrHMbwPAAD4Lb/ocSovLzdD7mbPnu3bFhQUJBMnTpQ1a9ZY1SwgIAUFOaR/aqyZpo3rYYb27Tt8VNbvPSzr9hw2802ZheY6qQPfZso732aax4UFB8kpnWPltK7xMrhrghne16dTjIRQdAIAALQzlgWnvLw8cTqdkpKSUmO7rm/evLnFXqesrMxM1VMlgMaH9qV3iDLTpUO7mG3FZZXyzb4jsn6PN0wdMeXQv9mXbyaRvb5rpU5Ni6sKU55A1bNjtAlnAAAA/srSa5zawvz58+W+++6zuhmA34sOD5FxvZPMpLRXau+hEvl2X758tz/flELfuD9fisudZqifTl4x4SGmZ0qH9nmn/imx3FcKAAD4DcuCU1JSkgQHB0t2dnaN7bqempraYq+jQwG1AEX1Hie9jgrAyfdKde8YbaaLh6T5rpXS6n3f7T/iCVT78mXjgXwpKquUr3YfNpOXdkD1TIr2BamBVfOUuHDz3AAAAHZiWXAKCwuTESNGyPLly2Xy5Mm+4hC6fvPNN7fY64SHh5sJQOvT4Xh9kmPM9NNhXc22SqdLduQWy6bMAjP9UDXPKyo323V6u+qaKZUYFSoDUuOkX0qM9EmJlX7JMdI3JVY6RIdZ+M4AAECgs3SonvYETZs2TUaOHGnu3aTlyIuLi2X69Olm/9SpU6VLly5muJ23oMQPP/zgW96/f79s2LBBYmJipE+fPla+FQD10EIR3sITk4d5rpdSOYWlpuCECVMHPGFKe6u0LPqanQfNVF3H6DDpmxIjfZNjPaGqat4xhn8YAQAArc/yG+BqKXLvDXCHDh0qjz/+uClTrs4++2xTdnzx4sVmfffu3dKzZ89azzFhwgRZuXJlk16PcuSAfZVWOGVbdpFsyS6UbTmFZnlrdqGp8Fcf7YnqmxwjvTrFSK+kaDP8r2enaOnWIUpCqe4HAABaKBtYHpzaGsEJ8D8l5ZWyPafIE6RyCmV71TzjUP2BKjjIYcKTCVJVU69O0dIrKYbrqAAAgP/cxwkAmioqLKTqPlEJtQLVjpxi0zu1O69YduQVy67cYtmVVyxHK5xmrlPt5wuWHh09YUpLrnfvGGVClk6d4yO4DxUAAKiFHicA7Y7+WssuKJOdeUWysypIeSctoe50uRvsqeqSEGnClIaqbtWnjlESFxHapu8FAAC0HnqcAAQ0HYaXGh9hJu99p7wqnC7JOFRiAtWeQyWy96AnTOmUcfiolFe6fOt1SYgKNSGqa2KkpMVHSpfESBO00hIizbb4yFCGAQIA0A4RnAAEFC0YYQpJdIqptU/vQ5VTWCZ7qsKUBqy91SYtoX6kpEKOlOSb+1TVJTos2IQoDVRm7p2qAlZybDhDAQEA8EMM1QOAJiouq5SMwyWy52CJ7D98VA4cOSr7jxyba7BqjA4FTI2LkLSECEmJizDL3t4x73JybISEhRCuAABobQzVA4BWEB0eYm7Oq1N95dRrhKnDR2VftWCVeaRUKl1us6xTQ5JiwnxhSgOWFq0wQatawIrleisAANoMwQkAWkhEaHC9wwCVFqXILSyT/UdKJDO/VLLySyW7oNQs6zyroFSy88uk3OkyvVc6bdxfUO/r6bDA5LgI6RQTLp1i65hiws3QQL1JsPZ0AQCAE0dwAoA2YobpVQ3Lq4+Onj5UXO4JUd5QpSHLBKsyyco/agJXQWmlFJfXX3K9Os1MHaKPC1Rxnnn1oJUUHS5xkSEUtwAAoA4EJwCwEQ0t2kOk06lp8fUep/ew0pLr2oOlU05hqW85t6hMcnRfUZkcLCoTrb6eV1Rmpk2ZDb9+aLBDOkSHmaClwwV1uWO0tkfnVevaPjMPk5hwghYAIDAQnADAT28K3DNJp+gGj9PhgQeLqwesY8sarHKrAlZOQanpwapweu6BpVNTaBELb4gyYeu4cJWoU1SoJER55lqunaqCAAB/RHACgHY+PFCr9OnUGC1uocMEDxaVm7Clc13PKy6TQ2Zb1VRUZraXlDvNfa90OKFOTRUXEWIClTdMJUbpsmd+LGRVbasKXpGhwfRsAQAsRXACAPiKW+i9p3RqiqPlThOwjoWtY6FKC1vovsPmvlflcri43FyXpXSuk5Z1byrt2To+ZOk8LjJU4iI8PVneKa76ckQIPVwAgBZBcAIAnJDIsGDpGhYlXROjmnR8pdMl+UcrjoWpEl0u9y17ApZ327G5VhnUnq3mDCE8vvqgN1BVD1WeYKXzEImPqjuAaZgEAEARnAAAbUJ7fryFL5pKqwzqkEDtxfKGKW+g0hCmU0HV3DsVllaaeVGZp4dLr93S6UAzhhNW7+nSXiu9Z5YWwog1yyESEx5q5r59Vdu9x3m367aoMIYZAkB7QHACANiWBg698bBO6R2a91jt4TLDAquFqoLSmiGr4Oix/dX36TatRqg9Xd57ap0oLQfvCV2eIOUNWJ4Advx2TyiLDg+W6DDP+9ZjvOtB3I8LACxDcAIAtNseLk9p9bBmP9blcktx+bGeK+3FKiz19GYdm2ru05BWpMtlx47TqoYawLzXdZ0s7b0yQdI79wUrnQebaoveZd++qm0mfFU7Pio0mCAGAM1AcAIA4DgaKDw9QaEn/Bw6zLC0wuUJXMeFLw1YBd5ls+9Y2NL14qrJLJc7TQBTOmxRp9wWep/VA5i3V0vDmQYwvYZN90f6tumy5xid+7aFeh7r2RZiKiBqNUcAaG8ITgAAtNIwQw0TOiWfxPNoACurdFWFKWdVmPKGK+exgKXzqu0l1Y4rqjrGN1ULYt7rv6Sw+UU3GhIeEmTCmIao+kNXPeEs1BPmdF9EiOdxuk2n8NAg89xcMwbACgQnAABsTEOCVvfTqWPMyT+fN4j5wpYGrfKqoFW1rKXmPb1bnnXPtmPL3u1HKzSUVe2rcIrbk8fM85dVnvh1YQ3RzBRZ9fPwzINqhCzvzypSt+vycQFMj/c+1nu89/nMc3m3hzCUEUBNBCcAAAI0iCU1o8JhUwOZBioNYBqqfCGrzGmCVZ3hq86QpsdXytFyl5Tp81Qc6yXTcOY9rrVpVUVvb5cvcFWFKl0PrzYPr9qvPWLeuZlqbTvuscftDwly0KMG2BTBCQAAtGggO5GCHI2pcLqkVMNXhVNKy12eedW6TmXe5Wr7zP5yp5RWerb7tvmOdZqwp3PvY3TdS6sq6qRFQtqKdnLVDmA1A5ovqB03r/cxIUEmBHrn3mXdZ9aDj20nuAH1IzgBAADbCw0OMtPJFOxoakVFT9DSwOUJVTUCV1XI8gxH9PSIeeel3nmF7vNs94Yx77zGctVjNJz5Xr9Gj1rbBbbqwe1YmDrWc+YNVt6QdWxbsNmmwc3Mqx3n3WaOOS68hfue59i+Wo8LDmK4JGyF4AQAAFBFv6hr4Qqd2oqGtXKnBilP4PIGrwYDmC+oNf4Yb7jT1/D2opn1qm3eYZCmLW4xz6GTyMmX0D9ZocGOqjAVbJY1PHsDlidM17EtxLPdu677zLzqWN0f5ptXbauaNNj5nrfac4Yd95zVX4MeusBBcAIAALA4rEUEeYY5irRuj1pdNDh5wpTzWKhyHhewzLZj+6tvLztuf/VtZTXCWtX+up672rHVVTjdUuGsqv5oU97w5p00jHnD2rGgdizgeY45FvqOBTSHuf9caFDV3Lutal2PCak6Rp8vJMiz7n0ds1xjm/d5jt8exC0DThDBCQAAIIDpl2hv6XyraZGR6j1j3p447za91s0Tpo7f5pKKSs9jK6ptL686tsK3rvuqtnmPdWpwdB573mqvc+x5jm2r3kNXPdyJ2DfcHU87yWqFrCANccdClmfdG+SqBbSg2sHMHOvb5ln3XjPnC3o1Hut5jQn9OlX9g4F/IDgBAADAFnTYm6eghX2/TGtw8oWpyvqDXPWA5g2B3mNrbPMe5/IsV7qOHVdptrs9c982zzEa+Cqr1r2P9yzXfKwue28V4KXrpr0m61kX+Nb+4VyCEwAAANBee+iCfUMr/YM37FXqvPJYyNJJA5QGMV8AqwpkJnRVevaZba6qkFffsd6wVsexJuhVhULfazpd5to1f0JwAgAAAAIg7Bktd/u2gBNkdQMAAAAAwO4ITgAAAADQCIITAAAAADSC4AQAAAAAjSA4AQAAAEAjCE4AAAAA0AiCEwAAAAA0guAEAAAAAI0gOAEAAABAIwhOAAAAANAIghMAAAAANILgBAAAAACNIDgBAAAAQCMITgAAAADQCIITAAAAADSC4AQAAAAAjSA4AQAAAEAjCE4AAAAA0IgQCTBut9vMCwoKrG4KAAAAAAt5M4E3IzQk4IJTYWGhmaenp1vdFAAAAAA2yQjx8fENHuNwNyVetSMul0sOHDggsbGx4nA4bJFyNcRlZGRIXFyc1c1BC+Cctj+c0/aJ89r+cE7bJ85r+1Ngo3OqUUhDU1pamgQFNXwVU8D1OOkPpGvXrmI3+j+N1f/joGVxTtsfzmn7xHltfzin7RPntf2Js8k5baynyYviEAAAAADQCIITAAAAADSC4GSx8PBwmTt3rpmjfeCctj+c0/aJ89r+cE7bJ85r+xPup+c04IpDAAAAAEBz0eMEAAAAAI0gOAEAAABAIwhOAAAAANAIghMAAAAANILgZKGFCxdKjx49JCIiQsaMGSNr1661ukkQkXvvvVccDkeNacCAAb79paWlctNNN0nHjh0lJiZGLr/8csnOzq7xHHv37pWLLrpIoqKiJDk5WX7/+99LZWVljWNWrlwpw4cPNxVl+vTpI4sXL26z9xgIPv30U7n44ovNncD1HL7xxhs19mtdnDlz5kjnzp0lMjJSJk6cKNu2batxzKFDh+Tqq682N+dLSEiQa6+9VoqKimoc8+2338r48ePN51jvgv7www/XasvLL79s/h/SY0477TR59913W+ldB/Y5/fWvf13rs3vBBRfUOIZzai/z58+XUaNGSWxsrPldOXnyZNmyZUuNY9rydy5/l9vuvJ599tm1Pq833HBDjWM4r/bx1FNPyeDBg303rB07dqy89957gfc51ap6aHsvvviiOywszP3ss8+6v//+e/d1113nTkhIcGdnZ1vdtIA3d+5c96mnnurOzMz0Tbm5ub79N9xwgzs9Pd29fPly93//+1/36aef7h43bpxvf2VlpXvQoEHuiRMnur/++mv3u+++605KSnLPnj3bd8zOnTvdUVFR7pkzZ7p/+OEH9xNPPOEODg52L1u2rM3fb3ulP/e7777b/dprr2nlUPfrr79eY/+DDz7ojo+Pd7/xxhvub775xn3JJZe4e/bs6T569KjvmAsuuMA9ZMgQ9xdffOFetWqVu0+fPu6rrrrKtz8/P9+dkpLivvrqq90bN250v/DCC+7IyEj33//+d98xn332mTm3Dz/8sDnXf/zjH92hoaHu7777ro1+EoFzTqdNm2bOWfXP7qFDh2ocwzm1l0mTJrmfe+4587PesGGD+8ILL3R369bNXVRU1Oa/c/m73LbndcKECeZnXP3zqp8/L86rvbz11lvud955x71161b3li1b3H/4wx/M7z09x4H0OSU4WWT06NHum266ybfudDrdaWlp7vnz51vaLniCk36xqsuRI0fML4qXX37Zt23Tpk3mS9yaNWvMuv4yCAoKcmdlZfmOeeqpp9xxcXHusrIys/4///M/JpxVN2XKFPPHBi3v+C/ZLpfLnZqa6n7kkUdqnNvw8HDzRVnpL2193FdffeU75r333nM7HA73/v37zfrf/vY3d2Jiou+8qrvuusvdv39/3/rPfvYz90UXXVSjPWPGjHH/9re/baV3GxjqC06XXnppvY/hnNpfTk6OOUeffPJJm//O5e9y251Xb3C69dZb630M59X+EhMT3f/4xz8C6nPKUD0LlJeXy7p168zQIK+goCCzvmbNGkvbBg8dsqXDgXr16mWG9Wj3stLzVlFRUePc6XCdbt26+c6dznXoTkpKiu+YSZMmSUFBgXz//fe+Y6o/h/cYzn/b2LVrl2RlZdU4B/Hx8abLv/p51KFcI0eO9B2jx+tn9csvv/Qdc9ZZZ0lYWFiN86hDUg4fPuw7hnPddnSYhw4B6d+/v8yYMUMOHjzo28c5tb/8/Hwz79ChQ5v+zuXvctueV6/nn39ekpKSZNCgQTJ79mwpKSnx7eO82pfT6ZQXX3xRiouLzZC9QPqchrTJq6CGvLw88z9d9f95lK5v3rzZsnbBQ78865ha/eKVmZkp9913n7neYePGjebLtn6h0i9fx5873ad0Xte59e5r6Bj9BXL06FFzzQ1aj/c81HUOqp8j/QJeXUhIiPnDX/2Ynj171noO777ExMR6z7X3OdBy9Hqmyy67zJyTHTt2yB/+8Af58Y9/bP6gBgcHc05tzuVyyW233SZnnHGG+SKt2up3roZi/i633XlVv/jFL6R79+7mHyn1usK77rrL/APFa6+9ZvZzXu3nu+++M0FJr2fS65hef/11GThwoGzYsCFgPqcEJ+A4+kXLSy+E1CClv9xfeuklAg1gYz//+c99y/ovm/r57d27t+mFOvfccy1tGxqnF5brP1CtXr3a6qagDc7r9ddfX+PzqoV69HOq/+ihn1vYT//+/U1I0h7EV155RaZNmyaffPKJBBKG6llAu6X1Xz+Przai66mpqZa1C3XTf0Hp16+fbN++3Zwf7So+cuRIvedO53WdW+++ho7RSjWEs9bnPQ8NfQZ1npOTU2O/Vv/Rqmwtca75rLc+HWqrv2/1s6s4p/Z18803y9tvvy0rVqyQrl27+ra31e9c/i637Xmti/4jpar+eeW82ktYWJipdDdixAhTOXHIkCHy17/+NaA+pwQni/7H0//pli9fXqMrW9e1CxT2oqWK9V/A9F/D9LyFhobWOHc6tECvgfKeO51rd3b1L2gffvih+eBrl7b3mOrP4T2G8982dCiW/pKtfg50KIBe51L9POofAR1P7fXxxx+bz6r3D7weoyWydWx39fOo/yqnQ7q8x3CurbFv3z5zjZN+dhXn1H60zod+udYhP3oujh8m2Va/c/m73LbntS7ak6Gqf145r/bmcrmkrKwssD6nbVKCArVoOUWt4LV48WJT6en666835RSrVxuBNe644w73ypUr3bt27TJlh7V0ppbM1KpA3pKbWlb1448/NiU3x44da6bjS26ef/75pgyrltHs1KlTnSU3f//735vKMwsXLqQceQsrLCw0JU910l91jz32mFnes2ePrxy5fubefPNN97fffmuqsdVVjnzYsGHuL7/80r169Wp33759a5Su1kpCWrr6V7/6lSnJqp9rPa/Hl64OCQlx//nPfzbnWqs2Urq65c+p7rvzzjtNBSf97H700Ufu4cOHm3NWWlrqew7Oqb3MmDHD3BZAf+dWL0tdUlLiO6atfufyd7ntzuv27dvd8+bNM+dTP6/6e7hXr17us846y/ccnFd7mTVrlqmKqOdL/2bqulYk/eCDDwLqc0pwspDWp9f/ybQevZZX1PuKwHpa+rJz587mvHTp0sWs6y95L/1ifeONN5oynPoB/+lPf2r+IFS3e/du949//GNz/xcNXRrGKioqahyzYsUK99ChQ83r6B8MvecFWo7+fPXL9fGTlqz2liS/5557zJdk/SV87rnnmntTVHfw4EHzpTomJsaUTJ0+fbr5gl6d3gPqzDPPNM+h/79oIDveSy+95O7Xr58511pqVe+FgZY9p/qFTP8g6x9iDTHdu3c39/c4/o8p59Re6jqfOlX/fdiWv3P5u9w253Xv3r0mJHXo0MF8zvR+avplufp9nBTn1T6uueYa83tVf4b6e1b/ZnpDUyB9Th36n7bp2wIAAAAA/8Q1TgAAAADQCIITAAAAADSC4AQAAAAAjSA4AQAAAEAjCE4AAAAA0AiCEwAAAAA0guAEAAAAAI0gOAEAWtXu3bvF4XDIhg0bxC42b94sp59+ukRERMjQoUPrPObss8+W2267TexGf5ZvvPGG1c0AgIBDcAKAdu7Xv/61+bL94IMP1tiuX751eyCaO3euREdHy5YtW2T58uV1HvPaa6/J/fff71vv0aOHLFiwoM3aeO+999YZ6jIzM+XHP/5xm7UDAOBBcAKAAKA9Kw899JAcPnxY2ovy8vITfuyOHTvkzDPPlO7du0vHjh3rPKZDhw4SGxsrdmq3Sk1NlfDw8BZrDwCgaQhOABAAJk6caL5wz58/v1k9HNrDoj0t1XuvJk+eLH/6058kJSVFEhISZN68eVJZWSm///3vTdjo2rWrPPfcc3UOjxs3bpwJcYMGDZJPPvmkxv6NGzeanpSYmBjz3L/61a8kLy+vxtC5m2++2QyfS0pKkkmTJtX5Plwul2mTtkMDhr6nZcuW+fZrL9u6devMMbqs77uxoXq6vGfPHrn99tvNY6r31K1evVrGjx8vkZGRkp6eLr/73e+kuLjYt19/ftpzNXXqVImLi5Prr7/ebL/rrrukX79+EhUVJb169ZJ77rlHKioqzL7FixfLfffdJ998843v9XRbXUP1vvvuO/nRj35kXl9DoD5/UVFRrXP25z//WTp37myOuemmm3yvpf72t79J3759zbnRn/0VV1xR588EAAIZwQkAAkBwcLAJO0888YTs27fvpJ7r448/lgMHDsinn34qjz32mBn29pOf/EQSExPlyy+/lBtuuEF++9vf1nodDVZ33HGHfP311zJ27Fi5+OKL5eDBg2bfkSNHzJf/YcOGyX//+18TdLKzs+VnP/tZjedYsmSJhIWFyWeffSaLFi2qs31//etf5dFHHzVB4dtvvzUB65JLLpFt27b5hrqdeuqppi26fOeddzb6nnXYngYxDVv6GJ28PVcXXHCBXH755ea1li5daoKUBrzqtC1Dhgwx710DktLeLA1DP/zwg2nzM888I3/5y1/MvilTppj2aTu9r6fbjqcBTd+f/uy/+uorefnll+Wjjz6q9forVqwwbdW5/gz1db1BTH/eGvb0venQRf3Zn3XWWY3+TAAg4LgBAO3atGnT3JdeeqlZPv30093XXHONWX799dfd1f8MzJ071z1kyJAaj/3LX/7i7t69e43n0nWn0+nb1r9/f/f48eN965WVle7o6Gj3Cy+8YNZ37dplXufBBx/0HVNRUeHu2rWr+6GHHjLr999/v/v888+v8doZGRnmcVu2bDHrEyZMcA8bNqzR95uWluZ+4IEHamwbNWqU+8Ybb/St6/vU99sQfb1bb73Vt67vW38e1V177bXu66+/vsa2VatWuYOCgtxHjx71PW7y5MmNtvuRRx5xjxgxosHzofRnoudOPf300+7ExER3UVGRb/8777xjXj8rK6vGOdPz4nXllVe6p0yZYpZfffVVd1xcnLugoKDRNgJAIKPHCQACiF7npD0OmzZtOuHn0F6QoKBjfz50aNdpp51Wo3dLh4Pl5OTUeJz2MnmFhITIyJEjfe3QIWnaG6LD9LzTgAEDzD7tKfEaMWJEg20rKCgwvWFnnHFGje26fjLvuT7abu25qd5u7QHS4YK7du3yHafv9XjaO6Xt0iGU+rg//vGPsnfv3ma9vr4n7cnSQhde+pz6+tp7VP2c6Xnx0iF73vNz3nnnmWu9dLigDo98/vnnpaSkpNk/CwBo7whOABBAdAiWfrGfPXt2rX0ahjwdGsdUvw7GKzQ0tMa6XnNT1zb98t5Uek2ODt3TkuXVJx1eV33YWPWAYAfabh2WWL3NGqa03b1796633WvWrJGrr75aLrzwQnn77bfNEL677777pAtH1Keh86NDBtevXy8vvPCCCVRz5swxYUyHTwIAjgmptgwACABallwLJvTv37/G9k6dOklWVpYJT97iBy1576UvvvjCF4K0mIQWaPBeizN8+HB59dVXTSEF7Y06UVp8IS0tzVwDNWHCBN92XR89evRJtV+vrXI6nTW2abv1GqU+ffo067k+//xz08ujYclLi0809nrHO+WUU0yPl17r5A1n+l41BB9/fhuiP3MtIKKTXrOmRT/0WrbLLrusWe8LANozepwAIMDosDrt7Xj88cdrbNfKcbm5ufLwww+b4XELFy6U9957r8VeV5/v9ddfN9X1tKqblka/5pprzD5dP3TokFx11VWmyIG+/vvvvy/Tp09vNDwcT4tQ6JBEHQqnw9VmzZplAuCtt956Uu3XUKcFMfbv3++r9qeV8TQEaQD09pC9+eabtYozHE8r2OmwvBdffNG8Vz0X+rM5/vV0uJ8+r75eWVlZrefR86iV8KZNm2aqEupwx1tuucUMudMhlE2hPV76+vo6Gt7+9a9/md6o5gQvAAgEBCcACEBaQe34oXTae6FlqTXg6FCttWvXNqniXHN6unTS59bKc2+99ZYpK668vUQaks4//3wT7rQUuPZ8VL+eqim0QtzMmTNNVTp9Hq0Sp6+lYeVkf2a7d+82Q/C0d04NHjzYlFXfunWrKUmuVQF1qJu+n4ZolT8tba4BS3v/NHx5q+15aaU+rdh3zjnnmNfToXTH01LmGjA1dI4aNcqUET/33HPlySefbPL70p+xVg3Uqob6/4BWK9TX0uuiAADHOLRCRLV1AAAAAMBx6HECAAAAgEYQnAAAAACgEQQnAAAAAGgEwQkAAAAAGkFwAgAAAIBGEJwAAAAAoBEEJwAAAABoBMEJAAAAABpBcAIAAACARhCcAAAAAKARBCcAAAAAaATBCQAAAACkYf8fN4CRmswVD/oAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def Logistic_Regression_(x, y, lr, num_iter):\n",
    "    intercept = np.ones((x.shape[0], 1))  # 初始化截距为 1\n",
    "    x = np.concatenate((intercept, x), axis=1)\n",
    "    w = np.zeros(x.shape[1])  # 初始化参数为 1\n",
    "\n",
    "    l_list = []  # 保存损失函数值\n",
    "    for i in range(num_iter):  # 梯度下降迭代\n",
    "        z = np.dot(x, w)  # 线性函数\n",
    "        h = sigmoid(z)  # sigmoid 函数\n",
    "\n",
    "        g = gradient(x, h, y)  # 计算梯度\n",
    "        w -= lr * g  # 通过学习率 lr 计算步长并执行梯度下降\n",
    "\n",
    "        l = loss(h, y)  # 计算损失函数值\n",
    "        l_list.append(l)\n",
    "\n",
    "    return l_list\n",
    "\n",
    "l_y = Logistic_Regression_(x, y, lr, num_iter)  # 训练\n",
    "\n",
    "# 绘图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot([i for i in range(len(l_y))], l_y)\n",
    "plt.xlabel(\"Number of iterations\")\n",
    "plt.ylabel(\"Loss function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e15e857",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "你会发现迭代到 20000 次之后，数据趋于稳定，也就接近于损失函数的极小值。你可以自行更改学习率和迭代次数尝试。 \n",
    "\n",
    "##  10.10.  逻辑回归 scikit-learn 实现  # \n",
    "\n",
    "上文的内容中，我们了解了逻辑回归的原理以及 Python 实现方式。这个过程很繁琐，但还是很有意义的。我们非常推荐你能至少搞清楚原理部分 80% 的内容。接下来，我们介绍 scikit-learn 中的逻辑回归方法，这个过程就会简单很多。 \n",
    "\n",
    "在 scikit-learn 中，实现逻辑回归的类及默认参数是： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c634690",
   "metadata": {},
   "outputs": [],
   "source": [
    "LogisticRegression(penalty='l2', dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='liblinear', max_iter=100, multi_class='ovr', verbose=0, warm_start=False, n_jobs=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b67543",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "介绍其中几个常用的参数，其余使用默认即可： \n",
    "\n",
    "  * ` penalty  ` : 惩罚项，默认为  $L_{2}$  范数。 \n",
    "\n",
    "  * ` dual  ` : 对偶化，默认为 False。 \n",
    "\n",
    "  * ` tol  ` : 数据解算精度。 \n",
    "\n",
    "  * ` fit_intercept  ` : 默认为 True，计算截距项。 \n",
    "\n",
    "  * ` random_state  ` : 随机数发生器。 \n",
    "\n",
    "  * ` max_iter  ` : 最大迭代次数，默认为 100。 \n",
    "\n",
    "另外， ` solver  ` 参数用于指定求解损失函数的方法。默认为 ` liblinear  ` （0.22 开始默认为 ` lbfgs  ` ），适合于小数据集。除此之外，还有适合多分类问题的 ` newton-cg  ` , ` sag  ` , ` saga  ` 和 ` lbfgs  ` 求解器。这些方法都来自于一些学术论文，有兴趣可以自行搜索了解。 \n",
    "\n",
    "那么，我们使用 scikit-learn 构建逻辑回归分类器的代码如下： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9220a31e",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 2.49579289, -4.01011301]]), array([-0.81713932]))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "model = LogisticRegression(\n",
    "    tol=0.001, max_iter=10000, solver=\"liblinear\"\n",
    ")  # 设置数据解算精度和迭代次数\n",
    "model.fit(x, y)\n",
    "model.coef_, model.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "607c5aad",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "你可能会发现得到的参数和上文 Python 实现得到的参数不一致，原因是我们的求解器不同。同样，我们可以将得到的分类边界线绘制成图。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5980ae8f",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x2354ea6b010>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df[\"X0\"], df[\"X1\"], c=df[\"Y\"])\n",
    "\n",
    "x1_min, x1_max = df[\"X0\"].min(), df[\"X0\"].max()\n",
    "x2_min, x2_max = df[\"X1\"].min(), df[\"X1\"].max()\n",
    "\n",
    "xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))\n",
    "grid = np.c_[xx1.ravel(), xx2.ravel()]\n",
    "\n",
    "probs = (np.dot(grid, model.coef_.T) + model.intercept_).reshape(xx1.shape)\n",
    "plt.contour(xx1, xx2, probs, levels=[0], linewidths=1, colors=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99b652c3",
   "metadata": {},
   "source": [
    "这段代码主要用于可视化一个分类问题的数据分布以及分类模型的决策边界。以下是逐行解释：\n",
    "\n",
    "---\n",
    "\n",
    "### 1. **绘制散点图**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64f329f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df[\"X0\"], df[\"X1\"], c=df[\"Y\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135a7659",
   "metadata": {},
   "source": [
    "- **`plt.figure(figsize=(10, 6))`**：\n",
    "  - 创建一个大小为 10x6 的绘图窗口。\n",
    "- **`plt.scatter(df[\"X0\"], df[\"X1\"], c=df[\"Y\"])`**：\n",
    "  - 绘制散点图：\n",
    "    - 横坐标为 `df[\"X0\"]`，纵坐标为 `df[\"X1\"]`。\n",
    "    - `c=df[\"Y\"]` 表示根据目标变量 `Y` 的值为每个点着色，通常用于区分不同类别。\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **获取数据范围**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebce0e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "x1_min, x1_max = df[\"X0\"].min(), df[\"X0\"].max()\n",
    "x2_min, x2_max = df[\"X1\"].min(), df[\"X1\"].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0124dcf4",
   "metadata": {},
   "source": [
    "- 获取 `X0` 和 `X1` 的最小值和最大值，用于生成网格范围。\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **生成网格点**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "342eb825",
   "metadata": {},
   "outputs": [],
   "source": [
    "xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))\n",
    "grid = np.c_[xx1.ravel(), xx2.ravel()]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "461e75fa",
   "metadata": {},
   "source": [
    "- **`np.meshgrid`**：\n",
    "  - 生成一个二维网格，`xx1` 和 `xx2` 分别表示网格的横坐标和纵坐标。\n",
    "  - `np.linspace(x1_min, x1_max)` 和 `np.linspace(x2_min, x2_max)` 用于在 `X0` 和 `X1` 的范围内生成等间距的点。\n",
    "- **`grid = np.c_[xx1.ravel(), xx2.ravel()]`**：\n",
    "  - 将网格点展平并组合成一个二维数组，每行是一个点的坐标，形状为 `(n_points, 2)`。\n",
    "\n",
    "---\n",
    "\n",
    "### 4. **计算决策边界的概率值**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39e72f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "probs = (np.dot(grid, model.coef_.T) + model.intercept_).reshape(xx1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d52a7a0a",
   "metadata": {},
   "source": [
    "- **`np.dot(grid, model.coef_.T)`**：\n",
    "  - 计算网格点与模型权重的点积，得到线性模型的输出。\n",
    "- **`+ model.intercept_`**：\n",
    "  - 加上模型的截距项。\n",
    "- **`.reshape(xx1.shape)`**：\n",
    "  - 将计算得到的概率值重新调整为与网格形状相同，以便后续绘图。\n",
    "\n",
    "---\n",
    "\n",
    "### 5. **绘制决策边界**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e4f90af",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contour(xx1, xx2, probs, levels=[0], linewidths=1, colors=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "987c32ff",
   "metadata": {},
   "source": [
    "- **`plt.contour`**：\n",
    "  - 绘制等高线图。\n",
    "  - `xx1` 和 `xx2` 是网格的横纵坐标，`probs` 是对应的概率值。\n",
    "  - `levels=[0]` 表示绘制概率值为 0 的等高线，即决策边界。\n",
    "  - `linewidths=1` 设置线宽为 1，`colors=\"red\"` 设置线的颜色为红色。\n",
    "\n",
    "---\n",
    "\n",
    "### 总结\n",
    "这段代码的作用是：\n",
    "1. 绘制数据点的散点图，展示数据分布。\n",
    "2. 计算分类模型的决策边界。\n",
    "3. 在图中绘制决策边界，用红色线表示分类的分界线。\n",
    "\n",
    "最终的图像展示了数据点的分布以及分类模型的决策边界，便于直观理解模型的分类效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adb68694",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "最后，我们可以看一下模型在训练集上的分类准确率： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9067bdd0",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9933333333333333"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.score(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa4baac6",
   "metadata": {},
   "source": [
    "那么，回到实验一开始的问题，也就是逻辑回归和线性回归之间关系的问题，我相信你应该已经有自己的答案了。 \n",
    "\n",
    "在我看来，「逻辑」二字是对逻辑分布的简称，也代表是与非，0 和 1 之间的逻辑，象征二分类问题。「回归」则源于线性回归，我们通过线性函数构建线性分类边界来达到分类的效果。 \n",
    "\n",
    "##  10.11.  总结  # \n",
    "\n",
    "本次实验中，我们学习到了一种叫做逻辑回归的分类方法。逻辑回归是非常常见和实用的二分类方法，通常会运用到垃圾邮件判断等实际问题中。另外，逻辑回归其实也可以完成多分类问题，但由于后面要学习在多分类问题上更占优势的其他方法，这里就不再讲解了。 \n",
    "\n",
    "相关链接 \n",
    "\n",
    "  * [ 逻辑回归-维基百科 ](https://zh.wikipedia.org/zh-hans/%E9%82%8F%E8%BC%AF%E8%BF%B4%E6%AD%B8)\n",
    "\n",
    "  * [ 梯度下降法-维基百科 ](https://zh.wikipedia.org/zh-hans/%E6%A2%AF%E5%BA%A6%E4%B8%8B%E9%99%8D%E6%B3%95)\n"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
